﻿/// \mainpage
/// \~chinese
/// \htmlinclude mainpage_chs.html
/// \~english
/// \htmlinclude mainpage_eng.html

#ifndef __MV_CAMERA_H__
#define __MV_CAMERA_H__
#include "IntTypes.h"

/**
*  @brief  锷ㄦ€佸簱瀵煎叆瀵煎嚭瀹氢箟
*/
#ifdef _MSC_VER
	#ifdef GENICAM_API_DLL_BUILD
		#define  GENICAM_API _declspec(dllexport)
	#elif defined GENICAM_API_DLL_USE
		#define  GENICAM_API _declspec(dllimport)
	#else
		#define GENICAM_API
	#endif
#elif defined __GNUC__
	#define GENICAM_API 
#else
	#define GENICAM_API
#endif

#if (defined (_WIN32) || defined(WIN64))
	#define CALL_METHOD __stdcall
#elif defined __GNUC__
	#define CALL_METHOD
#else
	#define CALL_METHOD
#endif // end #if (defined (_WIN32) || defined(WIN64))

#define MAX_PARAM_CNT         1000
#define MAX_STRING_LENTH      256
#define MAX_PAYLOAD_TYPE_CNT  20

#ifdef __cplusplus
extern "C" {
#endif 

/// \~chinese
/// \brief 锲惧儚镙煎纺
/// \defgroup ImageFormat 锲惧儚镙煎纺
/// @{
/// \~english
/// \brief Image Format
/// \defgroup ImageFormat Image Format
/// @{

//===================================================
// PIXEL FORMATS
//===================================================
// Indicate if pixel is monochrome or RGB

#define GVSP_PIX_MONO                           0x01000000
#define GVSP_PIX_RGB                            0x02000000 // deprecated in version 1.1
#define GVSP_PIX_COLOR                          0x02000000
#define GVSP_PIX_CUSTOM                         0x80000000
#define GVSP_PIX_COLOR_MASK                     0xFF000000

// Indicate effective number of bits occupied by the pixel (including padding).
// This can be used to compute amount of memory required to store an image.
#define GVSP_PIX_OCCUPY1BIT                     0x00010000
#define GVSP_PIX_OCCUPY2BIT                     0x00020000
#define GVSP_PIX_OCCUPY4BIT                     0x00040000
#define GVSP_PIX_OCCUPY8BIT                     0x00080000
#define GVSP_PIX_OCCUPY12BIT                    0x000C0000
#define GVSP_PIX_OCCUPY16BIT                    0x00100000
#define GVSP_PIX_OCCUPY24BIT                    0x00180000
#define GVSP_PIX_OCCUPY32BIT                    0x00200000
#define GVSP_PIX_OCCUPY36BIT                    0x00240000
#define GVSP_PIX_OCCUPY48BIT                    0x00300000
#define GVSP_PIX_EFFECTIVE_PIXEL_SIZE_MASK      0x00FF0000
#define GVSP_PIX_EFFECTIVE_PIXEL_SIZE_SHIFT     16

// Pixel ID: lower 16-bit of the pixel formats
#define GVSP_PIX_ID_MASK                        0x0000FFFF
#define GVSP_PIX_COUNT                          0x46 // next Pixel ID available

//max length of attribute name
#define MAX_ATTR_NAME_LEN 1024

enum EPixelType
{
	// Undefined pixel type
	pixelTypeUndefined = -1,

	// Mono Format
	gvspPixelMono1p = (GVSP_PIX_MONO | GVSP_PIX_OCCUPY1BIT | 0x0037),
	gvspPixelMono2p = (GVSP_PIX_MONO | GVSP_PIX_OCCUPY2BIT | 0x0038),
	gvspPixelMono4p = (GVSP_PIX_MONO | GVSP_PIX_OCCUPY4BIT | 0x0039),
	gvspPixelMono8 = (GVSP_PIX_MONO | GVSP_PIX_OCCUPY8BIT | 0x0001),
	gvspPixelMono8S = (GVSP_PIX_MONO | GVSP_PIX_OCCUPY8BIT | 0x0002),
	gvspPixelMono10 = (GVSP_PIX_MONO | GVSP_PIX_OCCUPY16BIT | 0x0003),
	gvspPixelMono10Packed = (GVSP_PIX_MONO | GVSP_PIX_OCCUPY12BIT | 0x0004),
	gvspPixelMono12 = (GVSP_PIX_MONO | GVSP_PIX_OCCUPY16BIT | 0x0005),
	gvspPixelMono12Packed = (GVSP_PIX_MONO | GVSP_PIX_OCCUPY12BIT | 0x0006),
	gvspPixelMono14 = (GVSP_PIX_MONO | GVSP_PIX_OCCUPY16BIT | 0x0025),
	gvspPixelMono16 = (GVSP_PIX_MONO | GVSP_PIX_OCCUPY16BIT | 0x0007),

	// Bayer Format
	gvspPixelBayGR8 = (GVSP_PIX_MONO | GVSP_PIX_OCCUPY8BIT | 0x0008),
	gvspPixelBayRG8 = (GVSP_PIX_MONO | GVSP_PIX_OCCUPY8BIT | 0x0009),
	gvspPixelBayGB8 = (GVSP_PIX_MONO | GVSP_PIX_OCCUPY8BIT | 0x000A),
	gvspPixelBayBG8 = (GVSP_PIX_MONO | GVSP_PIX_OCCUPY8BIT | 0x000B),
	gvspPixelBayGR10 = (GVSP_PIX_MONO | GVSP_PIX_OCCUPY16BIT | 0x000C),
	gvspPixelBayRG10 = (GVSP_PIX_MONO | GVSP_PIX_OCCUPY16BIT | 0x000D),
	gvspPixelBayGB10 = (GVSP_PIX_MONO | GVSP_PIX_OCCUPY16BIT | 0x000E),
	gvspPixelBayBG10 = (GVSP_PIX_MONO | GVSP_PIX_OCCUPY16BIT | 0x000F),
	gvspPixelBayGR12 = (GVSP_PIX_MONO | GVSP_PIX_OCCUPY16BIT | 0x0010),
	gvspPixelBayRG12 = (GVSP_PIX_MONO | GVSP_PIX_OCCUPY16BIT | 0x0011),
	gvspPixelBayGB12 = (GVSP_PIX_MONO | GVSP_PIX_OCCUPY16BIT | 0x0012),
	gvspPixelBayBG12 = (GVSP_PIX_MONO | GVSP_PIX_OCCUPY16BIT | 0x0013),
	gvspPixelBayGR10Packed = (GVSP_PIX_MONO | GVSP_PIX_OCCUPY12BIT | 0x0026),
	gvspPixelBayRG10Packed = (GVSP_PIX_MONO | GVSP_PIX_OCCUPY12BIT | 0x0027),
	gvspPixelBayGB10Packed = (GVSP_PIX_MONO | GVSP_PIX_OCCUPY12BIT | 0x0028),
	gvspPixelBayBG10Packed = (GVSP_PIX_MONO | GVSP_PIX_OCCUPY12BIT | 0x0029),
	gvspPixelBayGR12Packed = (GVSP_PIX_MONO | GVSP_PIX_OCCUPY12BIT | 0x002A),
	gvspPixelBayRG12Packed = (GVSP_PIX_MONO | GVSP_PIX_OCCUPY12BIT | 0x002B),
	gvspPixelBayGB12Packed = (GVSP_PIX_MONO | GVSP_PIX_OCCUPY12BIT | 0x002C),
	gvspPixelBayBG12Packed = (GVSP_PIX_MONO | GVSP_PIX_OCCUPY12BIT | 0x002D),
	gvspPixelBayGR16 = (GVSP_PIX_MONO | GVSP_PIX_OCCUPY16BIT | 0x002E),
	gvspPixelBayRG16 = (GVSP_PIX_MONO | GVSP_PIX_OCCUPY16BIT | 0x002F),
	gvspPixelBayGB16 = (GVSP_PIX_MONO | GVSP_PIX_OCCUPY16BIT | 0x0030),
	gvspPixelBayBG16 = (GVSP_PIX_MONO | GVSP_PIX_OCCUPY16BIT | 0x0031),

	// RGB Format
	gvspPixelRGB8 = (GVSP_PIX_COLOR | GVSP_PIX_OCCUPY24BIT | 0x0014),
	gvspPixelBGR8 = (GVSP_PIX_COLOR | GVSP_PIX_OCCUPY24BIT | 0x0015),
	gvspPixelRGBA8 = (GVSP_PIX_COLOR | GVSP_PIX_OCCUPY32BIT | 0x0016),
	gvspPixelBGRA8 = (GVSP_PIX_COLOR | GVSP_PIX_OCCUPY32BIT | 0x0017),
	gvspPixelRGB10 = (GVSP_PIX_COLOR | GVSP_PIX_OCCUPY48BIT | 0x0018),
	gvspPixelBGR10 = (GVSP_PIX_COLOR | GVSP_PIX_OCCUPY48BIT | 0x0019),
	gvspPixelRGB12 = (GVSP_PIX_COLOR | GVSP_PIX_OCCUPY48BIT | 0x001A),
	gvspPixelBGR12 = (GVSP_PIX_COLOR | GVSP_PIX_OCCUPY48BIT | 0x001B),
	gvspPixelRGB16 = (GVSP_PIX_COLOR | GVSP_PIX_OCCUPY48BIT | 0x0033),
	gvspPixelRGB10V1Packed = (GVSP_PIX_COLOR | GVSP_PIX_OCCUPY32BIT | 0x001C),
	gvspPixelRGB10P32 = (GVSP_PIX_COLOR | GVSP_PIX_OCCUPY32BIT | 0x001D),
	gvspPixelRGB12V1Packed = (GVSP_PIX_COLOR | GVSP_PIX_OCCUPY36BIT | 0X0034),
	gvspPixelRGB565P = (GVSP_PIX_COLOR | GVSP_PIX_OCCUPY16BIT | 0x0035),
	gvspPixelBGR565P = (GVSP_PIX_COLOR | GVSP_PIX_OCCUPY16BIT | 0X0036),

	// YVR Format
	gvspPixelYUV411_8_UYYVYY = (GVSP_PIX_COLOR | GVSP_PIX_OCCUPY12BIT | 0x001E),
	gvspPixelYUV422_8_UYVY = (GVSP_PIX_COLOR | GVSP_PIX_OCCUPY16BIT | 0x001F),
	gvspPixelYUV422_8 = (GVSP_PIX_COLOR | GVSP_PIX_OCCUPY16BIT | 0x0032),
	gvspPixelYUV8_UYV = (GVSP_PIX_COLOR | GVSP_PIX_OCCUPY24BIT | 0x0020),
	gvspPixelYCbCr8CbYCr = (GVSP_PIX_COLOR | GVSP_PIX_OCCUPY24BIT | 0x003A),
	gvspPixelYCbCr422_8 = (GVSP_PIX_COLOR | GVSP_PIX_OCCUPY16BIT | 0x003B),
	gvspPixelYCbCr422_8_CbYCrY = (GVSP_PIX_COLOR | GVSP_PIX_OCCUPY16BIT | 0x0043),
	gvspPixelYCbCr411_8_CbYYCrYY = (GVSP_PIX_COLOR | GVSP_PIX_OCCUPY12BIT | 0x003C),
	gvspPixelYCbCr601_8_CbYCr = (GVSP_PIX_COLOR | GVSP_PIX_OCCUPY24BIT | 0x003D),
	gvspPixelYCbCr601_422_8 = (GVSP_PIX_COLOR | GVSP_PIX_OCCUPY16BIT | 0x003E),
	gvspPixelYCbCr601_422_8_CbYCrY = (GVSP_PIX_COLOR | GVSP_PIX_OCCUPY16BIT | 0x0044),
	gvspPixelYCbCr601_411_8_CbYYCrYY = (GVSP_PIX_COLOR | GVSP_PIX_OCCUPY12BIT | 0x003F),
	gvspPixelYCbCr709_8_CbYCr = (GVSP_PIX_COLOR | GVSP_PIX_OCCUPY24BIT | 0x0040),
	gvspPixelYCbCr709_422_8 = (GVSP_PIX_COLOR | GVSP_PIX_OCCUPY16BIT | 0x0041),
	gvspPixelYCbCr709_422_8_CbYCrY = (GVSP_PIX_COLOR | GVSP_PIX_OCCUPY16BIT | 0x0045),
	gvspPixelYCbCr709_411_8_CbYYCrYY = (GVSP_PIX_COLOR | GVSP_PIX_OCCUPY12BIT | 0x0042),

	// RGB Planar
	gvspPixelRGB8Planar = (GVSP_PIX_COLOR | GVSP_PIX_OCCUPY24BIT | 0x0021),
	gvspPixelRGB10Planar = (GVSP_PIX_COLOR | GVSP_PIX_OCCUPY48BIT | 0x0022),
	gvspPixelRGB12Planar = (GVSP_PIX_COLOR | GVSP_PIX_OCCUPY48BIT | 0x0023),
	gvspPixelRGB16Planar = (GVSP_PIX_COLOR | GVSP_PIX_OCCUPY48BIT | 0x0024),

	//BayerRG10p鍜孊ayerRG12p镙煎纺锛岄拡瀵圭壒瀹氶」鐩复镞舵坊锷?璇蜂笉瑕佷娇鐢?
	//BayerRG10p and BayerRG12p, currently used for specific project, please do not use them
	gvspPixelBayRG10p = 0x010A0058,
	gvspPixelBayRG12p = 0x010c0059,

	//mono1c镙煎纺锛岃嚜瀹氢箟镙煎纺
	//mono1c, customized image format, used for binary output
	gvspPixelMono1c = 0x012000FF,

	//mono1e镙煎纺锛岃嚜瀹氢箟镙煎纺锛岀敤鏉ユ樉绀鸿繛阃氩烟
	//mono1e, customized image format, used for displaying connected domain
	gvspPixelMono1e = 0x01080FFF
};

/// @}



typedef enum GENICAM_ECameraAccessPermission
{
	accessPermissionOpen = 0,		///< \~chinese GigE鐩告満娌℃湁琚繛鎺?       ///< \~english The GigE vision device isn't connected to any application. 
	accessPermissionExclusive, 	///< \~chinese 镫崰璁块棶鏉冮檺        ///< \~english Exclusive Access Permission   
	accessPermissionControl, 	///< \~chinese 闱炵嫭鍗犲彲璇昏闂潈闄? ///< \~english Non-Exclusive Readbale Access Permission  
	accessPermissionControlWithSwitchover,  	///< \~chinese Control access with switchover enabled.        ///< \~english Control access with switchover enabled.	
	accessPermissionUnknown = 254,  	///< \~chinese 镞犳硶纭畾        ///< \~english Value not known; indeterminate.   	
	accessPermissionUndefined     	///< \~chinese 链畾涔夎闂潈闄?     ///< \~english Undefined Access Permission
}GENICAM_ECameraAccessPermission;


///< \~chinese
///鏋氢妇锛氩岗璁被鍨?
///< \~english
///enumeration: protocol type
typedef	enum GENICAM_EProtocolType
{
	typeGige = 0,	///< \~chinese GigE鍗忚        ///< \~english GigE Vision Protocol
	typeUsb3 = 1,	///< \~chinese USB3.0鍗忚      ///< \~english USB3.0 Vision Protocol
	typeCL   = 2,	///< \~chinese CAMERALINK鍗忚  ///< \~english Camera Link Protocol
    typePCIe = 3,   ///< \~chinese PCIe鎺ュ彛绫诲瀷    ///< \~english PCIe Protocol
	typeAll  = 255  ///< \~chinese 蹇界暐鍗忚绫诲瀷锛岃澶囧彂鐜颁紶鍏ユ绫诲瀷镞讹紝琛ㄧず闇€鍙戠幇镓€链夋帴鍙ｄ笅镄勮澶?  ///< \~english ALL Supported Protocol
}GENICAM_EProtocolType;

/// \~chinese
/// \brief 鐩告満瀵硅薄鎺ュ彛绫?
/// \defgroup Camera 鐩告満鍏辩敤鎿崭綔鎺ュ彛
/// @{
/// \~english
/// \brief Camera Object Interface Class
/// \defgroup Camera Camera Object Common Interface
/// @{

/// \~chinese
/// 阃氱敤鐩告満瀵硅薄
/// 32浣岖郴缁熶笅128瀛楄妭
/// \~english
/// universal camera object
/// 128 bytes in 32-bit system
typedef struct GENICAM_Camera
{
	/// \~chinese
	/// 搴曞眰绉佹湁鏁版嵁
	/// \~english
	/// underlying private data
	void *priv;
	
	/// \~chinese
	/// 澧炲姞鎺ュ彛寮旷敤
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \~english
	///  add interface reference
	/// \param [in] thiz this pointer
	int32_t	(*addRef)(struct GENICAM_Camera *thiz);

	/// \~chinese
	/// 閲婃斁鎺ュ彛
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \~english
	/// release interface
	/// \param [in] thiz this pointer	
	int32_t(*release)(struct GENICAM_Camera *thiz);
	
	/// \~chinese
	/// \brief  寰楀埌鐩告満绫诲瀷
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 鎴愬姛鍒栾繑锲?锛屽惁鍒栾繑锲?1
	/// \~english
	/// \brief  get Camera Type
	/// \param [in] thiz this pointer
	/// \return Success:0, Failure:-1
	int32_t (*getType)(struct GENICAM_Camera *thiz);
	
	/// \~chinese
	/// \brief  銮峰彇鐩告満鍚岖О
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 鎴愬姛杩斿洖鐩告満鍚岖О锛屽惁鍒栾繑锲濶ULL
	/// \~english
	/// \brief  get Camera Name
	/// \param [in] thiz this pointer
	/// \return Success:Camera Name, Failure:NULL
	const char* (*getName)(struct GENICAM_Camera *thiz);
	
	/// \~chinese
	/// \brief  銮峰彇鐩告満镄勫敮涓€镙囱瘑.
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 鎴愬姛杩斿洖鍞竴镙囱瘑鐩告満镄勫瓧绗︿覆锛屽け璐ヨ繑锲濶ULL
	/// \~english
	/// \brief  get Camera Unique Key
	/// \param [in] thiz this pointer
	/// \return Success:Key, Failure:NULL
	const char* (*getKey)(struct GENICAM_Camera *thiz);
	
    /// \~chinese
	/// \brief  杩炴帴璁惧
	/// 涓庣浉链哄缓绔嬭繛鎺ュ叧绯伙紝濡侴ige Vision鍗忚镄勭浉链哄嵆鏄幏寰楁带鍒舵潈闄愩€佸垱寤烘带鍒堕€氶亾
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \param [in] accessPermission 鐩墠鍙敮鎸乤ccessPermissionControl鏉冮檺锛岃皟鐢ㄨ鎺ュ彛镞朵紶鍏ユ绫绘潈闄?
	/// \retval < 0 杩炴帴璁惧澶辫触
	/// \retval 0   杩炴帴璁惧鎴愬姛
	/// \~english
	/// \brief  connect to camera
	/// establish connection with camera, for example, for GigE camera, which means get the control permission of camera and create control channel
	/// \param [in] thiz this pointer
	/// \param [in] accessPermission only accessPermissionControl supported currently
	/// \retval < 0 connection failed
	/// \retval 0   connection successful
	int32_t (*connect)(struct GENICAM_Camera *thiz,GENICAM_ECameraAccessPermission accessPermission);
		
	/// \~chinese
	/// \brief 鏂紑杩炴帴
	/// 鏂紑涓庣浉链虹殑杩炴帴鍏崇郴锛屽Gige Vision鍗忚镄勭浉链哄嵆鏄喷鏀炬带鍒舵潈闄愩€侀攒姣佹带鍒堕€氶亾
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \retval < 0 鏂紑璁惧澶辫触
	/// \retval 0   鏂紑璁惧鎴愬姛
	/// \~english
	/// \brief disconnect camera
	/// disconnect the camera, for example, for GigE camera, which means release the control permission of camera and destroy the control channel
	/// \param [in] thiz this pointer
	/// \retval < 0 disconnection failed
	/// \retval 0   disconnection successful
	int32_t (*disConnect)(struct GENICAM_Camera *thiz);
		
	/// \~chinese
	/// \brief 鍒ゆ柇鐩告満褰揿墠鏄惁澶勪簬宸茶繛鎺ョ姸镐?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \retval < 0 璁惧澶勪簬鏂紑钟舵€?
	/// \retval 0   璁惧澶勪簬杩炴帴钟舵€?
	/// \~english
	/// \brief check the camera is connected or disconnected
	/// \param [in] thiz this pointer
	/// \retval < 0 camera is disconnected
	/// \retval 0   camera is connected
	int32_t (*isConnected)(struct GENICAM_Camera *thiz);
		      								
	/// \~chinese
	/// \brief  銮峰彇鐩告満镓€灞炵殑鎺ュ彛鍚?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 鎴愬姛杩斿洖璁惧镓€灞炵殑鎺ュ彛鍚嶏紝鍚﹀垯杩斿洖NULL
	/// \~english
	/// \brief  get the name of interface whice is connect to camera
	/// \param [in] thiz this pointer
	/// \return Success:Interface Name, Failure:NULL
	const char* (*getInterfaceName)(struct GENICAM_Camera *thiz);

	/// \~chinese
	/// \brief  銮峰彇鐩告満镓€杩炴帴镄勬帴鍙ｇ被鍨?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖鐩告満镓€杩炴帴镄勬帴鍙ｇ被鍨?
	/// \~english
	/// \brief  get the type of interface which is connect to camera
	/// \param [in] thiz  this pointer
	/// \return the type of interface
	int32_t (*getInterfaceType)(struct GENICAM_Camera *thiz);
	
	/// \~chinese
	/// \brief 涓嬭浇鐩告満鎻忚堪XML鏂囦欢
	/// 涓嬭浇鐩告満鎻忚堪鏂囦欢锛屽苟淇濆瓨鍒版寚瀹氲矾寰?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \param [in] aFullFilename 鏂囦欢瑕佷缭瀛樼殑璺缎
	/// \retval < 0 涓嬭浇XML澶辫触
	/// \retval 0   涓嬭浇XML鎴愬姛
	/// \~english
	/// \brief download XML file of camera description 
	/// download camera discription file, and save the file to specified path
	/// \param [in] thiz this pointer
	/// \param [in] aFullFilename full path name of the downloaded xml file
	/// \retval < 0 download failed
	/// \retval 0   download successful
	int32_t (*downLoadGenICamXML)(struct GENICAM_Camera *thiz,const char* aFullFilename);

	/// \~chinese
	/// \brief 銮峰彇鐩告満鍒堕€犲巶鍟嗗悕绉?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖铡傚晢鍚岖О
	/// \~english
	/// \brief get camera's vendor 
	/// \param [in] thiz this pointer
	/// \return camera's vendor, return NULL if failed
	const char* (*getVendorName)(struct GENICAM_Camera *thiz);
	
	/// \~chinese
	/// \brief 銮峰彇鐩告満镄勫瀷鍙?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖鐩告満鍨嫔佛
	/// \~english
	/// \brief get camera's model name
	/// \param [in] thiz this pointer
	/// \return camera's model name, return NULL if failed
	const char* (*getModelName)(struct GENICAM_Camera *thiz);

	/// \~chinese
	/// \brief 銮峰彇鐩告満镄勫簭鍒楀佛
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖鐩告満镄勫簭鍒楀佛
	/// \~english
	/// \brief get camera's serial number
	/// \param [in] thiz this pointer
	/// \return camera's serial number, return NULL if failed
	const char* (*getSerialNumber)(struct GENICAM_Camera *thiz);

	/// \~chinese
	/// \brief 銮峰彇鐩告満锲轰欢鐗堟湰鍙?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖鐩告満镄勫浐浠剁増链佛
	/// \~english
	/// \brief get device version of this camera
	/// \param [in] thiz this pointer
	/// \return device version of this camera, return NULL if failed
	const char* (*getDeviceVersion)(struct GENICAM_Camera *thiz);

	/// \~chinese
	/// \brief 銮峰彇鐩告満鍒堕€犱俊鎭?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖鐩告満镄勫埗阃犱俊鎭?
	/// \~english
	/// \brief get manufacture info of this camera
	/// \param [in] thiz this pointer
	/// \return manufacture info of this camera, return NULL if failed
	const char* (*getManufactureInfo)(struct GENICAM_Camera *thiz);
	
	uint32_t		reserved[15];	///< \~chinese 淇濈暀  	///< \~english reserved field
}GENICAM_Camera;
/// @}


/// \~chinese
/// \brief 鍙戠幇璁惧銆佸垱寤哄父鐢ㄥ睘镐у璞?
/// \defgroup System 璁惧鍙戠幇銆佸睘镐у父鐢ㄥ璞″垱寤哄拰浜嬩欢璁㈤槄瀵硅薄鍒涘缓鎺ュ彛
/// @{
/// \~english
/// \brief discover camera, and create common property instance
/// \defgroup System System Management Interface
/// @{

/// \~chinese
/// \brief 鍏ㄥ眬鍗曚緥绯荤粺瀵硅薄,32浣岖郴缁熶笅128瀛楄妭
/// \~english
/// \brief Global singleton system object, 128 bytes in 32-bit system
typedef struct GENICAM_System
{
	/// \~chinese
	/// 搴曞眰绉佹湁鏁版嵁
	/// \~english
	/// Underlying private data
	void *priv;
	
	/// \~chinese
	/// 澧炲姞鎺ュ彛寮旷敤
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \~english
	/// add interface reference
	/// \param [in] thiz this pointer
	int32_t	(*addRef)(struct GENICAM_System *thiz);

	/// \~chinese
	/// 閲婃斁鎺ュ彛
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \~english
	/// release interface
	/// \param [in] thiz this pointer
	int32_t (*release)(struct GENICAM_System *thiz);
	
	/// \~chinese
	/// \brief 鍙戠幇鎸囧畾鎺ュ彛绫诲瀷鍙揪镄勮澶?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \param [out] ppCameraList 鎸囧畾鎺ュ彛绫诲瀷镓€链夊湪绾胯澶囧璞″垪琛?璇ュ唴瀛桦湪鍑芥暟鍐呴儴鐢宠锛屼絾闇€澶栭儴浼犲叆涓€涓竴缁存寚阍堟湁鏁埚湴鍧€鎸囧悜璇ヨ澶囧垪琛?
	/// \param [out] pCameraCnt  鍙戠幇镄勮澶囦釜鏁?
	/// \param [in]  interfaceType  鎺ュ彛绫诲瀷锛屽綋浼犲叆镄勬槸typeAll镞讹紝琛ㄧず鐩墠镓€链夊凡鏀寔镄勫岗璁被鍨嬭澶囬兘浼氲鍙戠幇
	/// \retval < 0 鍙戠幇璁惧澶辫触
	/// \retval 0   鍙戠幇璁惧鎴愬姛
	/// \~english
	/// \brief discover reachable camera which has specified interface type
	/// \param [in] thiz this pointer
	/// \param [out] ppCameraList camera instance list of specified interface type. thie memory is allocated inside the function, but it requires externally input a pointer of valid address to the device list
	/// \param [out] pCameraCnt  the number of discovered cameras
	/// \param [in]  interfaceType  interface type.when "typeAll" is specified which means all cameras which are currently supported will be discovered
	/// \retval < 0 discovery failed
	/// \retval 0   discovery successful
	int32_t (*discovery)(struct GENICAM_System *thiz, GENICAM_Camera **ppCameraList, uint32_t *pCameraCnt, GENICAM_EProtocolType interfaceType);
	
	/// \~chinese
	/// \brief 镙规嵁鐩告満镄刱ey銮峰彇 Camera 瀵硅薄鎸囬拡
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \param [in] pCameraKey 鐩告満镄刱ey
	/// \return 杩斿洖Camera鎸囬拡,鑻ヤ紶鍏ョ殑pCameraKey涓嶅瓨鍦ㄦ垨钥呴潪娉曪紝鍒栾繑锲炵┖鎸囬拡
	/// \~english
	/// \brief get the pointer of camera object according to camera key
	/// \param [in] thiz this pointer
	/// \param [in] pCameraKey camera key
	/// \return Success:camera pointer, Failure:NULL
	GENICAM_Camera* (*getCamera)(struct GENICAM_System *thiz,const char * pCameraKey);

	/// \~chinese
	/// \brief 銮峰彇鐗堟湰淇℃伅
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 鐗堟湰淇℃伅锛屽け璐ユ椂杩斿洖NULL
	/// \~english
	/// \brief get version info
	/// \param [in] thiz this pointer
	/// \return Success:version info, Failure:NULL
	const char* (*getVersion)(struct GENICAM_System *thiz);
	
	uint32_t		reserved[26];	///< 淇濈暀	///< \~english reserved field
}GENICAM_System;

/// \~chinese
/// 鍒涘缓绯荤粺瀵硅薄锛屽叏灞€鍞竴
///
/// \param [out] ppSystem 杈揿嚭鍙傛暟锛岃繑锲炵殑鏄郴缁熷璞＄殑鎸囬拡
/// \retval < 0 鍒涘缓澶辫触
/// \retval 0   鍒涘缓鎴愬姛
/// \~english
/// create system object, Globally unique
///
/// \param [out] ppSystem output parameter, return pointer of the system object
/// \retval < 0 create failed
/// \retval 0   create successful
GENICAM_API int32_t  CALL_METHOD GENICAM_getSystemInstance(GENICAM_System** ppSystem);
/// @}


/// \~chinese
/// \brief 鏁版嵁甯у璞℃帴鍙?
/// \defgroup Frame 鏁版嵁甯ф搷浣沧帴鍙?
/// @{
/// \~english 
/// \brief data frame object interface
/// \defgroup frame operation interface
/// @{
typedef enum GENICAM_EPayloadType
{
	payloadImage = 1,	            ///< \~chinese 锲剧墖         \~english Image
	payloadRawdata,					///< \~chinese 瑁告暟鎹?      \~english Raw Data
	payloadFile,					///< \~chinese 鏂囦欢         \~english File
	payloadChunkData,				///< \~chinese 鍧楁暟鎹?      \~english Chunk Data
	payloadExtChunkData,			///< \~chinese 镓╁睍鍧楁暟鎹?  \~english Extension Chunk Data
	payloadDevSpecBase = 0x8000,    ///< \~chinese 璁惧鐗规湁     \~english Device specific payload type
	payloadUndefined				///< \~chinese 链畾涔?	\~english Undefined
}GENICAM_EPayloadType;

/// \~chinese
/// \brief 鏁版嵁甯у璞?
/// 32浣岖郴缁熶笅128瀛楄妭
/// \~english
/// \brief data frame object
/// 128 bytes in 32-bit system
typedef struct GENICAM_Frame
{
	/// \~chinese
	/// 搴曞眰绉佹湁鏁版嵁
	/// \~english
	/// Underlying private data
	void *priv;

	/// \~chinese
	/// 澧炲姞鎺ュ彛寮旷敤
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \~english
	/// add interface reference
	/// \param [in] thiz this pointer
	int32_t (*addRef)(struct GENICAM_Frame *thiz);

	/// \~chinese
	/// 閲婃斁鎺ュ彛
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \~english
	/// release interface
	/// \param [in] thiz this pointer
	int32_t (*release)(struct GENICAM_Frame *thiz);

	/// \~chinese
	/// \brief 甯ф繁鎷疯礉鍏嬮殕鎺ュ彛
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 鏂扮殑涓€甯у璞?
	/// \~english
	/// \brief frame deep copy clone interface
	/// \param [in] thiz this pointer
	/// \return new frame object
	struct GENICAM_Frame* (*clone)(struct GENICAM_Frame *thiz);

	/// \~chinese
	/// \brief 澶栭溃涓崭娇鐢ㄦ椂闇€瑕佽皟鐢ㄦ鎺ュ彛閲婃斁Image鐩稿叧鍐呭瓨
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return none
	/// \~english
	/// \brief Call this interface to release image related memory externally when it is not in use
	/// \param [in] thiz this pointer
	/// \return none
	void (*reset)(struct GENICAM_Frame *thiz);

	/// \~chinese
	/// brief 鏄惁链夋晥
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \retval < 0 璇ュ抚镞犳晥
	/// \retval 0   璇ュ抚链夋晥
	/// \~english
	/// brief check the frame is valid or not
	/// \param [in] thiz this pointer
	/// \retval < 0 frame invalid
	/// \retval 0   frame valid
	int32_t (*valid)(struct GENICAM_Frame *thiz);

	/// \~chinese
	/// \brief 銮峰彇璇ュ抚锲剧墖鏁版嵁镄勫唴瀛橀鍦板潃
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖璇ュ抚锲剧墖鏁版嵁镄勫唴瀛橀鍦板潃
	/// \~english
	/// \brief Get the starting address of memory of this image data
	/// \param [in] thiz this pointer
	/// \return Return the starting address of memory of this image data  	
	const void* (*getImage)(struct GENICAM_Frame *thiz);

	/// \~chinese
	/// \brief 銮峰彇鏁版嵁甯х姸镐?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖鏁版嵁甯х姸镐?
	/// \~english
	/// \brief Get status of data frame
	/// \param [in] thiz this pointer
	/// \return the data frame status
	uint32_t (*getFrameStatus)(struct GENICAM_Frame *thiz);

	/// \~chinese
	/// \brief 銮峰彇锲剧墖瀹藉害
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖锲剧墖瀹藉害锛屽け璐ユ椂涓?
	/// \~english
	/// \brief get the width of image
	/// \param [in] thiz this pointer
	/// \return the width of image, return 0 when failed
	uint32_t (*getImageWidth)(struct GENICAM_Frame *thiz);

	/// \~chinese
	/// \brief 銮峰彇锲剧墖楂桦害
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖锲剧墖楂桦害锛屽け璐ユ椂涓?
	/// \~english 
	/// \brief get the height of image
	/// \param [in] thiz this pointer
	/// \return the height of image, return 0 when failed
	uint32_t (*getImageHeight)(struct GENICAM_Frame *thiz);

	/// \~chinese
	/// \brief 銮峰彇锲剧墖澶у皬
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖锲剧墖澶у皬锛屽け璐ユ椂涓?
	/// \~english
	/// \brief get the size of image
	/// \param [in] thiz this pointer
	/// \return the size of image, return 0 when failed
	uint32_t (*getImageSize)(struct GENICAM_Frame *thiz);

	/// \~chinese
	/// \brief 銮峰彇锲剧墖镀忕礌镙煎纺
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖锲剧墖镀忕礌镙煎纺
	/// \~english
	/// \brief get image pixel format
	/// \param [in] thiz this pointer
	/// \return image pixel format
	enum EPixelType (*getImagePixelFormat)(struct GENICAM_Frame *thiz);

	/// \~chinese
	/// \brief 銮峰彇锲剧墖镞堕棿鎴?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖锲剧墖镞堕棿鎴筹紝澶辫触镞朵负0
	/// \~english
	/// \brief get timestamp of image
	/// \param [in] thiz this pointer
	/// return image time stamp, return 0 when failed
	uint64_t (*getImageTimeStamp)(struct GENICAM_Frame *thiz);

	/// \~chinese
	/// \brief 銮峰彇锲剧墖瀵瑰簲镄凚lockId
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖锲剧墖瀵瑰簲镄凚lockId锛屽け璐ユ椂涓?
	/// \~english
	/// \brief get the image's block ID
	/// \param [in] thiz this pointer
	/// \return the image's block ID, return 0 when failed 
	uint64_t (*getBlockId)(struct GENICAM_Frame *thiz);

	/// \~chinese
	/// \brief 銮峰彇褰揿墠甯ф暟鎹噣钻风被鍨?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \param [in/out] pPayloadTypeList 褰揿墠甯ф暟鎹被鍨嬬绫婚泦锛屾渶澶х绫讳笉瓒呰绷MAX_PAYLOAD_TYPE_CNT锛岃鍐呭瓨澶栭儴鍒嗛厤
	/// \param [in/out] pTypeCnt 鍏ュ弬镞朵负鏁扮粍镄勫疄闄呴昵搴?鍑哄弬镞朵负褰揿墠甯ф暟鎹被鍨嬬殑瀹为台涓暟锛屾渶澶т笉瓒呰绷20
	/// \return 杩斿洖褰揿墠甯ф暟鎹噣钻风被鍨?
	/// \~english
	/// \brief get pay load type of current frame
	/// \param [in] thiz this pointer
	/// \param [in/out] pPayloadTypeList Current frame data type set, maximum type cannot excced MAX_PAYLOAD_TYPE_CNT, and the memory is allocated externally
	/// \param [in/out] pTypeCnt the actul length of array when input;the number of the current frame's data types when output, maximum value cannot exceed 20
	/// \return pay load type of current frame
	int32_t(*getPayLoadTypes)(struct GENICAM_Frame *thiz, GENICAM_EPayloadType aPayloadTypeList[MAX_PAYLOAD_TYPE_CNT], uint32_t *pTypeCnt);

	/// \~chinese
	/// \brief 銮峰彇Buffer涓寘鍚殑Chunk涓暟
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return Chunk涓暟
	/// \~english
	/// \brief get the number of chunk in buffer
	/// \param [in] thiz this pointer
	/// \return the number of chunk
	uint32_t (*getChunkCount)(struct GENICAM_Frame *thiz);

	/// \~chinese
	/// \brief 銮峰彇Chunk鏁版嵁
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \param [in] aIndex 绱㈠紩ID
	/// \param [out] pID ChunkID
	/// \param [in/out] aRefParamList Chunk鏁版嵁瀵瑰簲镄勫睘镐у悕,璇ュ唴瀛桦閮ㄥ垎閰嶏紝鎺ュ彛绾﹀畾ChunkID瀵瑰簲镄勫弬鏁板垪琛ㄦ渶澶т笉瓒呰绷MAX_PARAM_CNT涓紝姣忎釜灞炴€х殑瀛楃闀垮害涓嶈秴杩嘙AX_STRING_LENTH銆?
	/// \param [in/out] pParamCnt Chunk瀵瑰簲镄勫睘镐т釜鏁帮紝鍏ュ弬镞朵负链€澶х殑鍙傛暟涓暟锛屽嚭鍙傛椂涓哄疄闄呯殑鍙傛暟涓暟
	/// \return 鏄惁鎴愬姛
	/// \~english
	/// \brief get chunk data
	/// \param [in] thiz this pointer
	/// \param [in] aIndex index ID
	/// \param [out] pID ChunkID
	/// \param [in/out] aRefParamList Chunk data's property name, this memory is allocated externally, Chunk ID's property list cannot exceed MAX_PARAM_CNT, each property's characters cannot exceed MAX_STRING_LENTH
	/// \param [in/out] pParamCnt the number of chunk's property, maximum parameter's number when input, real parameter's number when output
	/// \return success or fail
	int32_t (*getChunkDataByIndex)(struct GENICAM_Frame *thiz,uint32_t aIndex, uint32_t *pID,
		char aRefParamList[MAX_PARAM_CNT][MAX_STRING_LENTH], uint32_t *pParamCnt);

	/// \~chinese
	/// \brief 銮峰彇锲剧墖paddingX
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖锲剧墖paddingX锛屽け璐ユ椂涓?
	/// \~english 
	/// \brief get the paddingX of image
	/// \param [in] thiz this pointer
	/// \return the paddingX of image, return 0 when failed
	uint32_t(*getImagePaddingX)(struct GENICAM_Frame *thiz);

	/// \~chinese
	/// \brief 銮峰彇锲剧墖paddingY
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖锲剧墖paddingY锛屽け璐ユ椂涓?
	/// \~english 
	/// \brief get the paddingY of image
	/// \param [in] thiz this pointer
	/// \return the paddingY of image, return 0 when failed
	uint32_t(*getImagePaddingY)(struct GENICAM_Frame *thiz);


	uint32_t  reserved[13];	///< \~chinese 淇濈暀  	///< \~english reserved field
}GENICAM_Frame;
/// @}


/// \~chinese
/// \brief 娴佸璞℃帴鍙ｇ被
/// \defgroup stream 娴佸璞℃搷浣沧帴鍙?
/// @{
/// \~english
/// \brief stream object interface class
/// \defgroup stream Stream Object Operation Interface 
/// @{
typedef enum  GENICAM_EGrabStrategy
{
	grabStrartegySequential = 0,	///< \~chinese 鎸夊埌杈鹃『搴忓鐞嗗浘鐗?///< \~english The images are processed in the order of their arrival
	grabStrartegyLatestImage = 1,   ///< \~chinese 銮峰彇链€鏂扮殑锲剧墖		///< \~english get latest image
	grabStrartegyUndefined   		///< \~chinese 链畾涔?			///< \~english undefined
}GENICAM_EGrabStrategy;

/// \~chinese
/// \brief 璁惧娴佸洖璋冨嚱鏁板０鏄?姣忔锲炶皟阃佸嚭涓€甯ф暟鎹?
/// pFrame 锲炶皟镞朵富锷ㄦ帹阃佺殑甯у璞?澶栭儴鐢ㄥ畲璇ュ抚鍚庨渶瑕侀喷鏀?
/// \~english
/// \brief Callback function declaration of stream: Send out one frame at each time use callback function
/// pFrame The frame which will be active pushed out during the callback, when this frame is used externally then it is required to be released
typedef void(*callbackFun)(GENICAM_Frame* pFrame);

/// \~chinese
/// \brief 璁惧娴佸洖璋冨嚱鏁板０鏄?姣忔锲炶皟阃佸嚭涓€甯ф暟鎹?
/// pFrame 锲炶皟镞朵富锷ㄦ帹阃佺殑甯у璞?澶栭儴鐢ㄥ畲璇ュ抚鍚庨渶瑕侀喷鏀?
/// pUser  鐢ㄦ埛镊畾涔夋暟鎹?
/// \~english
/// \brief Callback function declaration of stream: Send out one frame at each time use callback function
/// pFrame The frame which will be active pushed out during the callback, when this frame is used externally then it is required to be released
/// pUser  user defined data
typedef void(*callbackFunEx)(GENICAM_Frame* pFrame, void* pUser);

/// \~chinese
/// \brief GENICAM_StreamSource 娴佸璞?
/// 32浣岖郴缁熶笅128瀛楄妭
/// \~english
/// \brief stream object
/// 128 bytes in 32-bit system
typedef struct GENICAM_StreamSource
{
	/// \~chinese
	/// 搴曞眰绉佹湁鏁版嵁
	/// \~english
	/// Underlying private data
	void *priv;

	/// \~chinese
	/// 澧炲姞鎺ュ彛寮旷敤
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \~english
	/// add interface reference
	/// \param [in] thiz this pointer
	int32_t (*addRef)(struct GENICAM_StreamSource *thiz);

	/// \~chinese
	/// 閲婃斁鎺ュ彛
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \~english
	/// release interface
	/// \param [in] thiz this pointer
	int32_t (*release)(struct GENICAM_StreamSource *thiz);

	/// \~chinese
	/// \brief 寮€濮嬫姄锲?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \param [in] maxImagesGrabbed 鍏佽链€澶氱殑鎶揿浘鏁帮紝杈惧埌鎸囧畾鎶揿浘鏁板悗锅沧鎶揿浘锛屽鏋滀负0锛岃〃绀哄拷鐣ユ鍙傛暟锛屼细杩炵画鎶揿浘
	/// \param [in] strategy 鎶揿浘绛栫暐
	/// \return 杩斿洖鎶揿浘鏄惁鎴愬姛锛?琛ㄧず鎴愬姛锛?1琛ㄧず澶辫触
	/// \~english
	/// \brief Start grabbing
	/// \param [in] thiz this pointer
	/// \param [in] maxImagesGrabbed Maximum images allowed to grab, once it reaches the limit then stop grabbing; If it is 0, then ignore this parameter and start grabbing continuously
	/// \param [in] strategy Image grabbing strategy
	/// \return success:0, fail:-1
	int32_t (*startGrabbing)(struct GENICAM_StreamSource *thiz, uint64_t maxImagesGrabbed, GENICAM_EGrabStrategy strategy);

	/// \~chinese
	/// \brief 锅沧鎶揿浘
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖锅沧鎶揿浘鏄惁鎴愬姛锛?琛ㄧず鎴愬姛锛?1琛ㄧず澶辫触	
	/// \~english
	/// \brief Stop grabbing
	/// \param [in] thiz this pointer
	/// \return success:0, fail:-1
	int32_t (*stopGrabbing)(struct GENICAM_StreamSource *thiz);

	/// \~chinese
	/// \brief 鏄惁姝ｅ湪鎶揿浘
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖鏄惁澶勪簬鎷夋祦钟舵€侊紝0琛ㄧず澶勪簬鎷夋祦钟舵€侊紝-1琛ㄧず闱炴媺娴佺姸镐?
	/// \~english 
	/// \brief Check whether it is grabbing or not
	/// \param [in] thiz this pointer
	/// \return grabbing or not grabbing, 0 means it is grabbing, -1 means it is not grabbing
	int32_t (*isGrabbing)(struct GENICAM_StreamSource *thiz);

	/// \~chinese
	/// \brief 銮峰彇涓€甯у浘镀忥紝璇ユ帴鍙ｄ笉鏀寔澶氱嚎绋嬭皟鐢?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \param [out] ppFrame 涓€甯у浘镀?鍐呭瓨鐢卞嚱鏁板唴閮ㄥ垎閰嶏紝鐢ㄥ畲璇ュ抚鍚庨渶瑕佹樉绀鸿皟鐢℅ENICAM_Frame release鎺ュ彛鏄剧ず閲婃斁
	/// \param [in]  timeoutMS 銮峰彇涓€甯у浘镀忕殑瓒呮椂镞堕昵,鍗曚綅MS,褰揿€间负INFINITE镞惰〃绀烘棤闄愮瓑寰?
	/// \return 杩斿洖鏄惁鎴愬姛锛?琛ㄧず鎴愬姛锛?1琛ㄧず澶辫触
	/// \~english
	/// \brief get a frame image, and this interface does not support multi-threading
	/// \param [in] thiz this pointer
	/// \param [out] ppFrame There is one image, its memory is allocated internally in this function, it is also required to call GENICAM_Frame release interface to release memory after use up this image
	/// \param [in]  The timeout value of getting one image, unit is MS; When the value is INFINITE which means infinite wait
	/// \return success:0, fail:-1
	int32_t (*getFrame)(struct GENICAM_StreamSource *thiz, GENICAM_Frame **ppFrame, uint32_t timeoutMS);

	/// \~chinese
	/// \brief 娉ㄥ唽鏁版嵁甯у洖璋冨嚱鏁般€傝寮傛銮峰彇甯ф満鍒跺拰鍚屾銮峰彇甯ф満鍒朵簰鏂ワ紝绯荤粺涓袱钥呭彧鑳介€夊叾涓€銆?
	/// \brief 鍙兘澶勭悊涓€涓洖璋冨嚱鏁?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \param [in] proc 鏁版嵁甯у洖璋冨嚱鏁帮紝寤鸿涓嶈鍦ㄨ鍑芥暟涓鐞呜€楁椂镄勬搷浣滐紝鍚﹀垯浼氶樆濉炲悗缁暟鎹抚镄勫疄镞舵€?
	/// \return 杩斿洖娉ㄥ唽鏄惁鎴愬姛锛?琛ㄧず鎴愬姛锛?1琛ㄧず澶辫触
	/// \~english
	/// \brief Register data frame callback function; This asynchronous frame acquisition mechanism and synchronous frame acquisition mechanism are mutually exclusive, only one method can be choosed between these two in system
	/// \brief only process one callback unction 
	/// \param [in] thiz this pointer
	/// \param [in] proc Data frame callback function; It is advised to not put time-cosuming operation in this function, otherwise it will block follow-up data frames and affect real time performance
	/// \return success:0, fail:-1
	int32_t (*attachGrabbing)(struct GENICAM_StreamSource *thiz, callbackFun proc);

	/// \~chinese
	/// \brief 铡绘敞鍐屾暟鎹抚锲炶皟鍑芥暟
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \param [in] proc 铡绘敞鍐屾暟鎹抚锲炶皟鍑芥暟
	/// \return 杩斿洖铡绘敞鍐屾槸鍚︽垚锷燂紝0琛ㄧず鎴愬姛锛?1琛ㄧず澶辫触
	/// \~english
	/// \brief	Unregister data frame callback function
	/// \param [in] thiz this pointer
	/// \param [in] proc Unregister data frame callback function
	/// \return success:0, fail:-1
	int32_t(*detachGrabbing)(struct GENICAM_StreamSource *thiz, callbackFun proc);

	/// \~chinese
	/// \brief 璁剧疆缂揿瓨涓暟,涓嶈兘鍦ㄦ媺娴佽绷绋嬩腑璁剧疆
	/// \param [in] thiz 鎸囬拡
	/// \param [in]  缂揿瓨鏁伴噺
	/// \return 杩斿洖鏄惁鎴愬姛
	/// \~english
	/// \brief set number of buffer,it can not be set in Grabbing.
	/// \param [in] thiz this pointer
	/// \param [in] number of buffer
	/// \return success:0, fail:-1
	int32_t(*setBufferCount)(struct GENICAM_StreamSource *thiz, uint32_t nSize);

	/// \~chinese
	/// \brief 娉ㄥ唽鏁版嵁甯у洖璋冨嚱鏁?鍖呭惈鐢ㄦ埛镊畾涔夋暟鎹?銆傝寮傛銮峰彇甯ф満鍒跺拰鍚屾銮峰彇甯ф満鍒朵簰鏂ワ紝绯荤粺涓袱钥呭彧鑳介€夊叾涓€銆?
	/// \brief 鍙兘澶勭悊涓€涓洖璋冨嚱鏁?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \param [in] proc 鏁版嵁甯у洖璋冨嚱鏁帮紝寤鸿涓嶈鍦ㄨ鍑芥暟涓鐞呜€楁椂镄勬搷浣滐紝鍚﹀垯浼氶樆濉炲悗缁暟鎹抚镄勫疄镞舵€?
	/// \param [in] pUser 鐢ㄦ埛镊畾涔夋暟鎹?
	/// \return 杩斿洖娉ㄥ唽鏄惁鎴愬姛锛?琛ㄧず鎴愬姛锛?1琛ㄧず澶辫触
	/// \~english
	/// \brief Register data frame callback function(include user defined data); This asynchronous frame acquisition mechanism and synchronous frame acquisition mechanism are mutually exclusive, only one method can be choosed between these two in system
	/// \brief only process one callback unction 
	/// \param [in] thiz this pointer
	/// \param [in] proc Data frame callback function; It is advised to not put time-cosuming operation in this function, otherwise it will block follow-up data frames and affect real time performance
	/// \param [in] pUser user defined data
	/// \return success:0, fail:-1
	int32_t(*attachGrabbingEx)(struct GENICAM_StreamSource *thiz, callbackFunEx proc, void* pUser);

	/// \~chinese
	/// \brief 铡绘敞鍐屾暟鎹抚锲炶皟鍑芥暟(鍖呭惈鐢ㄦ埛镊畾涔夋暟鎹?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \param [in] proc 铡绘敞鍐屾暟鎹抚锲炶皟鍑芥暟
	/// \param [in] pUser 鐢ㄦ埛镊畾涔夋暟鎹?涓巃ttachGrabbingEx镄刾User鐩稿悓)
	/// \return 杩斿洖铡绘敞鍐屾槸鍚︽垚锷燂紝0琛ㄧず鎴愬姛锛?1琛ㄧず澶辫触
	/// \~english
	/// \brief	Unregister data frame callback function(include user defined data)
	/// \param [in] thiz this pointer
	/// \param [in] proc Unregister data frame callback function(the same pUser of the attachGrabbingEx)
	/// \param [in] pUser user defined data
	/// \return success:0, fail:-1
	int32_t(*detachGrabbingEx)(struct GENICAM_StreamSource *thiz, callbackFunEx proc, void* pUser);


    /// \~chinese
    /// \brief 璁剧疆椹卞姩鍖呴棿闅旀椂闂?ms),浠呭Gige璁惧链夋晥
    /// \param [in] thiz 链帴鍙ｆ寚阍?
    /// \param [in] nTimeout 鍖呴棿闅旀椂闂达紝鍗曚綅ms
    /// \return 璁剧疆鏄惁鎴愬姛,0琛ㄧず鎴愬姛锛?1琛ㄧず澶辫触
    /// \~english
    /// \brief	set packet timeout(ms),just for GigE devices
    /// \param [in] thiz this pointer
    /// \param [in] the value of timeout
    /// \return success:0, fail:-1
    int32_t(*setInterPacketTimeout)(struct GENICAM_StreamSource *thiz, uint32_t nTimeout);

	uint32_t  reserved[19];	///< \~chinese 淇濈暀  	///< \~english reserved field

}GENICAM_StreamSource;

/// \~chinese
/// \brief 娴佸璞″弬鏁?
/// 32浣岖郴缁熶笅128瀛楄妭
/// \~english
/// \brief stream object parameter
/// 128 bytes in 32-bit system
typedef struct GENICAM_StreamSourceInfo
{
	GENICAM_Camera*  pCamera;	///< \~chinese 鐩告満瀵硅薄		///< \~english camera object
	uint32_t channelId;         ///< \~chinese 阃氶亾鍙?	///< \~english ID of channel
	uint32_t reserved[30];	    ///< \~chinese 淇濈暀			///< \~english reserved field
} GENICAM_StreamSourceInfo;

/// \~chinese
/// 鍒涘缓娴侀€氶亾瀵硅薄锛岃瀵硅薄鐢卞閮ㄨ皟鐢ㄨ鎺ュ彛鍒涘缓锛岄喷鏀炬椂璋幂敤release鎺ュ彛
///
/// \param [in] pStreamSourceInfo 鍒涘缓娴佸璞＄殑鍙傛暟
/// \param [out] ppStreamSource   杩斿洖镄勬祦瀵硅薄
/// \retval < 0 鍒涘缓澶辫触
/// \retval 0   鍒涘缓鎴愬姛
/// \~english
/// create stream channel object, this object is created by external call, and it requires to call release interface when release it
/// \param [in] pStreamSourceInfo create parameter of stream object
/// \param [out] ppStreamSource   return stream object
/// \retval < 0 create failed
/// \retval 0   create successful
GENICAM_API int32_t CALL_METHOD GENICAM_createStreamSource(const GENICAM_StreamSourceInfo* pStreamSourceInfo
										, GENICAM_StreamSource** ppStreamSource);
										
/// @}


typedef enum EVType
{
	offLine,   ///< \~chinese 璁惧绂荤嚎阃氱煡    ///< \~english device offline notification
	onLine     ///< \~chinese 璁惧鍦ㄧ嚎阃氱煡    ///< \~english device online notification
}EVType;

/// \~chinese
/// \brief 浜嬩欢娉ㄥ唽锲炶皟瀵硅薄鎺ュ彛绫?
/// \defgroup Event 鐩告満浜嬩欢璁㈤槄娉ㄥ唽涓庡幓娉ㄥ唽鎺ュ彛
/// @{
/// \~english
/// \brief event subscribe callback interface class
/// \defgroup Event register camera event subscribe and unsubscribe interface 
/// @{

/// \~chinese
/// \brief 杩炴帴浜嬩欢鍙傛暟灏佽
/// \~english
/// \brief connection event parameters encapsulation
typedef struct GENICAM_SConnectArg
{
	EVType m_event;  		///< \~chinese 浜嬩欢绫诲瀷    ///< \~english event type
	uint32_t reserve[15]; 	///< \~chinese 棰勭暀瀛楁    ///< \~english reserved field
}GENICAM_SConnectArg;

/// \~chinese
/// 鍙傛暟镟存柊浜嬩欢鍙傛暟灏佽
/// \~english
/// updating parameters event encapsulation
typedef struct GENICAM_SParamUpdataArg
{
	int32_t isPoll; 					                 ///< \~chinese 鏄惁鏄畾镞舵洿鏂?1琛ㄧず鏄畾镞舵洿鏂帮紝0琛ㄧず闱炲畾镞舵洿鏂?  ///< \~english update periodically or not. 1 : update periodically, 0 : not update periodically
	uint32_t reserve[10];		                         ///< \~chinese 棰勭暀瀛楁                 ///< \~english reserved field
	char paramNames[MAX_PARAM_CNT][MAX_STRING_LENTH];    ///< \~chinese 镟存柊镄勫弬鏁板悕绉伴泦鍚?绾﹀畾镟存柊镄勫弬鏁颁笉瓒呰绷1000涓紝姣忎釜鍙傛暟镄勫瓧绗︿覆闀垮害涓嶈秴杩?56  ///< \~english array of parameter's name which need to be updated. the maximum number of parameters is 1000. and the max length of strings of each parameter is 255.
	uint32_t referenceParamCnt;                          ///< \~chinese 镟存柊镄勫弬鏁颁釜鏁?          ///< \~english the number of parameters which need update
}GENICAM_SParamUpdataArg;

/// \~chinese
///鏋氢妇锛氭祦浜嬩欢钟舵€?
/// \~english
/// enumeration:stream event status
typedef enum GENICAM_EEventStatus
{
	streamEventNormal = 1,      ///< \~chinese 姝ｅ父娴佷簨浠?	///< \~english normal stream event
	streamEventLostFrame = 2,   ///< \~chinese 涓㈠抚浜嬩欢		    ///< \~english lost frame event
	streamEventLostPacket = 3,  ///< \~chinese 涓㈠寘浜嬩欢		    ///< \~english lost packet event
	streamEventImageError = 4,       ///< \~chinese 锲惧儚阌栾浜嬩欢		///< \~english error image event
	streamEventStreamChannelError   ///< \~chinese 鍙栨祦阌栾浜嬩欢 		///< \~english stream channel error event
}GENICAM_EEventStatus;

/// \~chinese
/// \brief 娴佷簨浠跺弬鏁板皝瑁?
/// \~english
/// \brief stream event parameters encapsulation
typedef struct GENICAM_SStreamArg
{
	uint32_t     channel;					 ///< \~chinese 娴侀€氶亾鍙?        ///< \~english channel no.
	uint64_t     blockID;					 ///< \~chinese 娴佹暟鎹瓸lockID    ///< \~english block ID of stream data
	uint64_t     timestamp;					 ///< \~chinese 镞堕棿鎴?          ///< \~english event timestamp
	GENICAM_EEventStatus eStreamEventStatus; ///< \~chinese 娴佷簨浠剁姸镐佺爜     ///< \~english stream event status code
	uint32_t	 status;					 ///< \~chinese 浜嬩欢钟舵€侀敊璇爜   ///< \~english status error code
	uint32_t reserve[9];					 ///< \~chinese 棰勭暀瀛楁         ///< \~english reserved field
}GENICAM_SStreamArg;

/// \~chinese
/// 娑堟伅阃氶亾浜嬩欢ID鍒楄〃
/// \~english
/// message channel event id list
#define MSG_EVENT_ID_EXPOSURE_END			0x9001
#define MSG_EVENT_ID_FRAME_TRIGGER			0x9002
#define MSG_EVENT_ID_FRAME_START			0x9003
#define MSG_EVENT_ID_ACQ_START				0x9004
#define MSG_EVENT_ID_ACQ_TRIGGER			0x9005
#define MSG_EVENT_ID_DATA_READ_OUT			0x9006

// \~chinese
/// \brief 娴佷簨浠跺弬鏁板皝瑁?
/// \~english
/// \brief stream event parameters encapsulation
typedef struct GENICAM_SMsgChannelArg
{
	uint16_t  eventID;         ///< \~chinese 浜嬩欢Id			///< \~english event id
	uint16_t  channelID;       ///< \~chinese 娑堟伅阃氶亾鍙?	///< \~english channel id
	uint64_t  blockID;		   ///< \~chinese 娴佹暟鎹瓸lockID		///< \~english block ID of stream data
	uint64_t  timeStamp;       ///< \~chinese 镞堕棿鎴?		///< \~english event timestamp
	uint32_t   reserve[8];	   ///< \~chinese 棰勭暀瀛楁         ///< \~english reserved field
	char paramNames[MAX_PARAM_CNT][MAX_STRING_LENTH];   ///< \~chinese 浜嬩欢鐩稿叧镄勫睘镐у悕鍒楄〃銆傜害瀹氩睘镐у悕涓嶈秴杩?000涓紝姣忎釜灞炴€у悕镄勫瓧绗︿覆闀垮害涓嶈秴杩?56  ///< \~english array of parameter's name which is related. the maximum number of parameters is 1000. and the max length of strings of each parameter is 255.
	uint32_t referenceParamCnt;///< \~chinese 鍙傛暟涓暟           ///< \~english the number of parameters which need update
}GENICAM_SMsgChannelArg;

/// \~chinese
/// \brief 璁惧杩炴帴钟舵€佷簨浠跺洖璋冨嚱鏁板０鏄?
/// \~english
/// \brief call back function declaration of camera connection status event 
typedef void (*connectCallBack)(const GENICAM_SConnectArg* pConnectArg);

/// \~chinese
/// \brief 璁惧杩炴帴钟舵€佷簨浠跺洖璋冨嚱鏁板０鏄?
/// \~english
/// \brief call back function declaration of camera connection status event 
typedef void(*connectCallBackEx)(const GENICAM_SConnectArg* pConnectArg, void* pUser);

/// \~chinese
/// \brief 鍙傛暟镟存柊浜嬩欢锲炶皟鍑芥暟澹版槑
/// \~english
/// \brief call back function declaration of camera parameter update event 
typedef void (*paramUpdateCallBack)(const GENICAM_SParamUpdataArg* pParamUpdateArg);

/// \~chinese
/// \brief 鍙傛暟镟存柊浜嬩欢锲炶皟鍑芥暟澹版槑
/// \~english
/// \brief call back function declaration of camera parameter update event 
typedef void(*paramUpdateCallBackEx)(const GENICAM_SParamUpdataArg* pParamUpdateArg, void* pUser);

/// \~chinese
/// \brief 璁惧娴佷簨浠跺洖璋冨嚱鏁板０鏄?
/// \~english
/// \brief call back function declaration of stream event 
typedef void (*streamCallBack)(const GENICAM_SStreamArg* pStreamArg);

/// \~chinese
/// \brief 璁惧娴佷簨浠跺洖璋冨嚱鏁板０鏄?
/// \~english
/// \brief call back function declaration of stream event 
typedef void(*streamCallBackEx)(const GENICAM_SStreamArg* pStreamArg, void *pUser);

/// \~chinese
/// \brief 娑堟伅阃氶亾浜嬩欢锲炶皟鍑芥暟澹版槑
/// \~english
/// \brief call back function declaration of message channel event 
typedef void(*msgChannelCallBackEx)(const GENICAM_SMsgChannelArg* pMsgChannelArg, void *pUser);

/// \~chinese
/// \brief 浜嬩欢璁㈤槄瀵硅薄
/// 32浣岖郴缁熶笅128瀛楄妭
/// \~english
/// \brief event subscribe object
/// 128 bytes in 32-bit system
typedef struct GENICAM_EventSubscribe
{
	/// \~chinese
	/// 搴曞眰绉佹湁鏁版嵁
	/// \~english
	/// Underlying private data
	void *priv;

	/// \~chinese
	/// 澧炲姞鎺ュ彛寮旷敤
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \~english
	/// add interface reference
	/// \param [in] thiz this pointer
	int32_t(*addRef)(struct GENICAM_EventSubscribe *thiz);

	/// \~chinese
	/// 閲婃斁鎺ュ彛
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \~english
	/// release interface
	/// \param [in] thiz this pointer
	int32_t(*release)(struct GENICAM_EventSubscribe *thiz);

	/// \~chinese
	/// \brief  璁惧杩炴帴钟舵€佷簨浠跺洖璋冩敞鍐?鍙敮鎸佷竴涓洖璋冨嚱鏁版湁鏁?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \param [in] proc  璁惧杩炴帴钟舵€佷簨浠跺洖璋冩敞鍐屽嚱鏁?
	/// \return 娉ㄥ唽鏄惁鎴愬姛
	/// \~english
	/// \brief  register call back function of camera connection status event. only support one valid call back function
	/// \param [in] thiz this pointer
	/// \param [in] proc  register call back function of camera connection status event
	/// \return the result of registration
	int32_t(*subscribeConnectArgs)(struct GENICAM_EventSubscribe *thiz, const connectCallBack proc);

	/// \~chinese
	/// \brief  璁惧杩炴帴钟舵€佷簨浠跺洖璋冨幓娉ㄥ唽
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \param [in] proc  璁惧杩炴帴钟舵€佷簨浠跺洖璋冨幓娉ㄥ唽鍑芥暟
	/// \return 铡绘敞鍐屾槸鍚︽垚锷?
	/// \~english
	/// \brief  unregister call back function of camera connection status event.
	/// \param [in] thiz this pointer
	/// \param [in] proc  unregister call back function of camera connection status event
	/// \return the result of unregistration
	int32_t(*unsubscribeConnectArgs)(struct GENICAM_EventSubscribe *thiz, const connectCallBack proc);

	/// \~chinese
	/// \brief  鍙傛暟镟存柊浜嬩欢锲炶皟娉ㄥ唽,鍙敮鎸佷竴涓洖璋冨嚱鏁版湁鏁?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \param [in] proc 鍙傛暟镟存柊娉ㄥ唽镄勪簨浠跺洖璋冨嚱鏁?
	/// \return 娉ㄥ唽鏄惁鎴愬姛
	/// \~english
	/// \brief  register call back function of parameter update event. only support one valid call back function
	/// \param [in] thiz this pointer
	/// \param [in] proc  register call back function of parameter update event
	/// \return the result of registration
	int32_t (*subscribeParamUpdate)(struct GENICAM_EventSubscribe *thiz, const paramUpdateCallBack proc);

	/// \~chinese
	/// \brief  鍙傛暟镟存柊浜嬩欢锲炶皟铡绘敞鍐?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \param [in] proc 鍙傛暟镟存柊浜嬩欢铡绘敞鍐岀殑锲炶皟鍑芥暟
	/// \return 铡绘敞鍐屾槸鍚︽垚锷?
	/// \~english
	/// \brief  unregister call back function of parameter update event.
	/// \param [in] thiz this pointer
	/// \param [in] proc  unregister call back function of parameter update event
	/// \return the result of unregistration
	int32_t (*unsubscribeParamUpdate)(struct GENICAM_EventSubscribe *thiz, const paramUpdateCallBack proc);

	/// \~chinese
	/// \brief  娴侀€氶亾浜嬩欢锲炶皟娉ㄥ唽,鍙敮鎸佷竴涓洖璋冨嚱鏁版湁鏁?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \param [in] proc 娴侀€氶亾浜嬩欢锲炶皟娉ㄥ唽鍑芥暟
	/// \return 娉ㄥ唽鏄惁鎴愬姛
	/// \~english
	/// \brief  register call back function of stream channel event. only support one valid call back function
	/// \param [in] thiz this pointer
	/// \param [in] proc  register call back function of stream channel event
	/// \return the result of registration
	int32_t (*subscribeStreamArg)(struct GENICAM_EventSubscribe *thiz, const streamCallBack proc);

	/// \~chinese
	/// \brief  娴侀€氶亾浜嬩欢锲炶皟铡绘敞鍐?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \param [in] proc  娴侀€氶亾浜嬩欢锲炶皟铡绘敞鍐屽嚱鏁?
	/// \return 铡绘敞鍐屾槸鍚︽垚锷?
	/// \~english
	/// \brief  unregister call back function of stream channel event.
	/// \param [in] thiz this pointer
	/// \param [in] proc  unregister call back function of stream channel event
	/// \return the result of unregistration
	int32_t (*unsubscribeStreamArg)(struct GENICAM_EventSubscribe *thiz, const streamCallBack proc);

    /// \~chinese
    /// \brief  璁惧杩炴帴钟舵€佷簨浠跺洖璋冩敞鍐?鍙敮鎸佷竴涓洖璋冨嚱鏁版湁鏁?
    /// \param [in] thiz 链帴鍙ｆ寚阍?
    /// \param [in] proc  璁惧杩炴帴钟舵€佷簨浠跺洖璋冩敞鍐屽嚱鏁?
    /// \param [in] pUser   鐢ㄦ埛镊畾涔夋暟鎹?
    /// \return 娉ㄥ唽鏄惁鎴愬姛
    /// \~english
    /// \brief  register call back function of camera connection status event. only support one valid call back function
    /// \param [in] thiz this pointer
    /// \param [in] proc  register call back function of camera connection status event
    /// \param [in] pUser user data
    /// \return the result of registration
    int32_t(*subscribeConnectArgsEx)(struct GENICAM_EventSubscribe *thiz, const connectCallBackEx proc, void* pUser);

    /// \~chinese
    /// \brief  璁惧杩炴帴钟舵€佷簨浠跺洖璋冨幓娉ㄥ唽
    /// \param [in] thiz 链帴鍙ｆ寚阍?
    /// \param [in] proc  璁惧杩炴帴钟舵€佷簨浠跺洖璋冨幓娉ㄥ唽鍑芥暟
    /// \param [in] pUser   鐢ㄦ埛镊畾涔夋暟鎹?
    /// \return 铡绘敞鍐屾槸鍚︽垚锷?
    /// \~english
    /// \brief  unregister call back function of camera connection status event.
    /// \param [in] thiz this pointer
    /// \param [in] proc  unregister call back function of camera connection status event
    /// \param [in] pUser user data
    /// \return the result of unregistration
    int32_t(*unsubscribeConnectArgsEx)(struct GENICAM_EventSubscribe *thiz, const connectCallBackEx proc, void *pUser);

	/// \~chinese
	/// \brief  鍙傛暟镟存柊浜嬩欢锲炶皟娉ㄥ唽,鍙敮鎸佷竴涓洖璋冨嚱鏁版湁鏁?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \param [in] proc 鍙傛暟镟存柊娉ㄥ唽镄勪簨浠跺洖璋冨嚱鏁?
    /// \param [in] pUser   鐢ㄦ埛镊畾涔夋暟鎹?
	/// \return 娉ㄥ唽鏄惁鎴愬姛
	/// \~english
	/// \brief  register call back function of parameter update event. only support one valid call back function
	/// \param [in] thiz this pointer
	/// \param [in] proc  register call back function of parameter update event
    /// \param [in] pUser user data
	/// \return the result of registration
	int32_t (*subscribeParamUpdateEx)(struct GENICAM_EventSubscribe *thiz, const paramUpdateCallBackEx proc, void* pUser);

	/// \~chinese
	/// \brief  鍙傛暟镟存柊浜嬩欢锲炶皟铡绘敞鍐?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \param [in] proc 鍙傛暟镟存柊浜嬩欢铡绘敞鍐岀殑锲炶皟鍑芥暟
    /// \param [in] pUser   鐢ㄦ埛镊畾涔夋暟鎹?
	/// \return 铡绘敞鍐屾槸鍚︽垚锷?
	/// \~english
	/// \brief  unregister call back function of parameter update event.
	/// \param [in] thiz this pointer
	/// \param [in] proc  unregister call back function of parameter update event
    /// \param [in] pUser user data
	/// \return the result of unregistration
	int32_t (*unsubscribeParamUpdateEx)(struct GENICAM_EventSubscribe *thiz, const paramUpdateCallBackEx proc, void* pUser);

	/// \~chinese
	/// \brief  娴侀€氶亾浜嬩欢锲炶皟娉ㄥ唽,鍙敮鎸佷竴涓洖璋冨嚱鏁版湁鏁?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \param [in] proc 娴侀€氶亾浜嬩欢锲炶皟娉ㄥ唽鍑芥暟
    /// \param [in] pUser 鐢ㄦ埛镊畾涔夋暟鎹?
	/// \return 娉ㄥ唽鏄惁鎴愬姛
	/// \~english
	/// \brief  register call back function of stream channel event. only support one valid call back function
	/// \param [in] thiz this pointer
	/// \param [in] proc  register call back function of stream channel event
    /// \param [in] pUser user data
	/// \return the result of registration
	int32_t (*subscribeStreamArgEx)(struct GENICAM_EventSubscribe *thiz, const streamCallBackEx proc, void* pUser);

	/// \~chinese
	/// \brief  娴侀€氶亾浜嬩欢锲炶皟铡绘敞鍐?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \param [in] proc  娴侀€氶亾浜嬩欢锲炶皟铡绘敞鍐屽嚱鏁?
    /// \param [in] pUser  鐢ㄦ埛镊畾涔夋暟鎹?
	/// \return 铡绘敞鍐屾槸鍚︽垚锷?
	/// \~english
	/// \brief  unregister call back function of stream channel event.
	/// \param [in] thiz this pointer
	/// \param [in] proc  unregister call back function of stream channel event
    /// \param [in] pUser user data
	/// \return the result of unregistration
	int32_t (*unsubscribeStreamArgEx)(struct GENICAM_EventSubscribe *thiz, const streamCallBackEx proc, void* pUser);

	/// \~chinese
	/// \brief  娑堟伅阃氶亾浜嬩欢锲炶皟娉ㄥ唽,鍙敮鎸佷竴涓洖璋冨嚱鏁版湁鏁?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \param [in] proc 娑堟伅阃氶亾浜嬩欢锲炶皟娉ㄥ唽鍑芥暟
	/// \return 娉ㄥ唽鏄惁鎴愬姛
	/// \~english
	/// \brief  register call back function of message channel event. only support one valid call back function
	/// \param [in] thiz this pointer
	/// \param [in] proc  register call back function of message channel event
	/// \return the result of registration
	int32_t(*subscribeMsgChannelEx)(struct GENICAM_EventSubscribe *thiz, const msgChannelCallBackEx proc, void* pUser);

	/// \~chinese
	/// \brief  娑堟伅阃氶亾浜嬩欢锲炶皟铡绘敞鍐?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \param [in] proc  娑堟伅阃氶亾浜嬩欢锲炶皟铡绘敞鍐屽嚱鏁?
	/// \return 铡绘敞鍐屾槸鍚︽垚锷?
	/// \~english
	/// \brief  unregister call back function of message channel event.
	/// \param [in] thiz this pointer
	/// \param [in] proc  unregister call back function of message channel event
	/// \return the result of unregistration
	int32_t(*unsubscribeMsgChannelEx)(struct GENICAM_EventSubscribe *thiz, const msgChannelCallBackEx proc, void* pUser);
	
	uint32_t reserve[15];					 ///< \~chinese 棰勭暀瀛楁    ///< \~english reserved field
}GENICAM_EventSubscribe;

/// \~chinese
/// \brief 浜嬩欢璁㈤槄瀵硅薄鍙傛暟
/// 32浣岖郴缁熶笅128瀛楄妭
/// \~english
/// \brief event subscribe info object
/// 128 bytes in 32-bit system
typedef struct GENICAM_EventSubscribeInfo
{
	GENICAM_Camera*  pCamera;	///< \~chinese 鐩告満瀵硅薄    ///< \~english camera object
	uint32_t reserved[31];	    ///< \~chinese 淇濈暀        ///< \~english reserved field
} GENICAM_EventSubscribeInfo;

/// \~chinese
/// 鍒涘缓浜嬩欢璁㈤槄瀵硅薄
/// \param [in] pEventSubscribeInfo  鍒涘缓浜嬩欢璁㈤槄瀵硅薄镄勫弬鏁?
/// \param [out] ppEventSubscribe    杩斿洖镄勪簨浠惰阒呭璞?
/// \retval < 0 鍒涘缓澶辫触
/// \retval 0   鍒涘缓鎴愬姛
/// \~english
/// create event subscribe object
/// \param [in] pEventSubscribeInfo  create event subscribe info object
/// \param [out] ppEventSubscribe    return event subscribe object
/// \retval < 0 create failed
/// \retval 0   create successfully
GENICAM_API int32_t  CALL_METHOD GENICAM_createEventSubscribe(const GENICAM_EventSubscribeInfo* pEventSubscribeInfo,
													GENICAM_EventSubscribe** ppEventSubscribe);
/// @}


/// \~chinese
/// \brief 鐩告満瀵硅薄鎺ュ彛绫?
/// \defgroup GENICAM_GigECamera  GigE鐩告満瀵硅薄鎿崭綔鎺ュ彛
/// @{
/// \~english
/// \brief camera object interface class
/// \defgroup GENICAM_GigECamera  GigeVision Camera Object Operation Interface
/// @{
/// \~chinese													
/// \brief GiGE鐩告満鐗规畩鎺ュ彛
/// 32浣岖郴缁熶笅128瀛楄妭
/// \~english
/// \brief GigE camera specific object
/// 128 bytes in 32-bit system
typedef struct GENICAM_GigECamera
{
	/// \~chinese
	/// 搴曞眰绉佹湁鏁版嵁
	/// \~english
	/// Underlying private data
	void *priv;

	/// \~chinese
	/// 澧炲姞鎺ュ彛寮旷敤
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \~english
	/// add interface reference
	/// \param [in] thiz this pointer
	int32_t(*addRef)(struct GENICAM_GigECamera *thiz);

	/// \~chinese
	/// 閲婃斁鎺ュ彛
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \~english
	/// release interface
	/// \param [in] thiz this pointer
	int32_t(*release)(struct GENICAM_GigECamera *thiz);

	/// \~chinese
	/// \brief 銮峰彇鐩告満镄刬pAddress
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖ipAddress 鐩告満镄処P鍦板潃锛屽け璐ヨ繑锲濶ULL
	/// \~english
	/// \brief	get camera's ipAddress
	/// \param [in] thiz this pointer
	/// \return return camera's ipAddress, return NULL if failed 
	const char* (*getIpAddress)(struct GENICAM_GigECamera *thiz);

	/// \~chinese
	/// \brief 杩斿洖鐩告満镄勫瓙缃戞帺镰?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖subnetMask 鐩告満镄勫瓙缃戞帺镰侊紝澶辫触杩斿洖NULL
	/// \~english
	/// \brief return camera's subnetMask
	/// \param [in] thiz this pointer
	/// \return camera's subnetMask, return NULL if failed
	const char* (*getSubnetMask)(struct GENICAM_GigECamera *thiz);

	/// \~chinese
	/// \brief 杩斿洖鐩告満镄勭綉鍏?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖 gateway 鐩告満镄勭綉鍏筹紝澶辫触杩斿洖NULL
	/// \~english
	/// \brief return camera's gateway
	/// \param [in] thiz this pointer
	/// \return camera's gateway, return NULL if failed
	const char*  (*getGateway)(struct GENICAM_GigECamera *thiz);

	/// \~chinese
	/// \brief 銮峰彇鐩告満镄?macAddress
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖macAddress 鐩告満镄凪ac鍦板潃锛屽け璐ヨ繑锲濶ULL
	/// \~english
	/// \brief get camera's macAddress
	/// \param [in] thiz this pointer
	/// \return camera's macAddress, return NULL if failed
	const char*  (*getMacAddress)(struct GENICAM_GigECamera *thiz);

	/// \~chinese
	/// \brief  淇敼璁惧IP	
	/// \brief 1銆佽皟鐢ㄨ鍑芥暟镞跺鏋渘ewSubnetMask鍜宯ewGateway閮借缃简链夋晥链硷紝鍒欎互姝ゆ湁鏁埚€间负鍑?
	/// \brief 2銆佽皟鐢ㄨ鍑芥暟镞跺鏋渘ewSubnetMask鍜宯ewGateway閮借缃简NULL锛屽垯鍐呴儴瀹炵幇镞剁敤瀹冩墍杩炴帴缃戝崱镄勫瓙缃戞帺镰佸拰缃戝叧浠ｆ浛
	/// \brief 3銆佽皟鐢ㄨ鍑芥暟镞跺鏋渘ewSubnetMask鍜宯ewGateway涓よ€呬腑鍏朵腑涓€涓负NULL锛屽彟涓€涓潪NULL锛屽垯杩斿洖澶辫触
	/// \brief 璇ユ帴鍙ｅ彧阍埚阃氲绷缃戝崱鎺ュ叆镄勮澶囷紝瀵逛簬鍏朵綑璁惧锛岃皟鐢ㄦ鎺ュ彛镞犳剰涔夛紝鐩存帴杩斿洖澶辫触
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \param [in] newIpAddress 鏂扮殑IP鍦板潃淇℃伅
	/// \param [in] newSubnetMask 鏂扮殑鎺╃爜淇℃伅
	/// \param [in] newGateway 鏂扮殑缃戝叧淇℃伅
	/// \retval < 0 淇敼IP澶辫触
	/// \retval 0   淇敼IP鎴愬姛
	/// \~english
	/// \brief  modify device IP	
	/// \brief 1銆乄hen callback this function, if the values of newSubnetMask and newGateway are both valid then we consider the value is correct
	/// \brief 2銆乄hen callback this function, if the values of newSubnetMask and newGateway are both NULL, then these values will be replaced by the subnetmask and gateway of NIC which this camera connect to.
	/// \brief 3銆乄hen callback this function, if there is one value of newSubnetMask or newGateway is NULL and the other one is not NULL, then return failed
	/// \brief this interface only serve the devices which is connected to NIC. As for other devices, callback this function won't work and return failed
	/// \param [in] thiz this pointer
	/// \param [in] newIpAddress new ip address 
	/// \param [in] newSubnetMask new subnetMask
	/// \param [in] newGateway new Gateway
	/// \retval < 0 modify ip failed
	/// \retval 0   modify ip success
	int32_t (*forceIpAddress)(struct GENICAM_GigECamera *thiz,const char* newIpAddress, const char* newSubnetMask, const char* newGateway);

	/// \~chinese
	/// \brief 銮峰彇鐩告満镄勫綋鍓嶈闂潈闄?
	/// \return 濡傛灉銮峰彇鎴愬姛锛岃繑锲炵殑鏋氢妇链间唬琛ㄧ浉链虹殑褰揿墠璁块棶鏉冮檺锛屽鏋滃け璐ワ紝杩斿洖镄勬灇涓惧€间负accessPermissionUnknown
	/// \~english
	/// \brief	get current access permission of camera
	/// \return success:return current access permission of camera, fail:return accessPermissionUnknown 
	GENICAM_ECameraAccessPermission (*getAccessPermission)(struct GENICAM_GigECamera *thiz);

	/// \~chinese
	/// \brief 銮峰彇鐩告満镄?Protocol Version
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖鐩告満镄凯rotocol Version锛屽け璐ヨ繑锲濶ULL
	/// \~english
	/// \brief get camera's Protocol Version
	/// \param [in] thiz this pointer
	/// \return camera's Protocol Version, return NULL if failed
	const char*  (*getProtocolVersion)(struct GENICAM_GigECamera *thiz);

	/// \~chinese
	/// \brief 銮峰彇鐩告満镄?IP Configuration
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖鐩告満镄処P Configuration锛屽け璐ヨ繑锲濶ULL
	/// \~english
	/// \brief get camera's IP Configuration
	/// \param [in] thiz this pointer
	/// \return camera's IP Configuration, return NULL if failed
	const char*  (*getIPConfiguration)(struct GENICAM_GigECamera *thiz);

	uint32_t reserve[21];					 ///< \~chinese 棰勭暀瀛楁    ///< \~english reserved field
}GENICAM_GigECamera;

/// \~chinese
/// \brief 鍒涘缓GigECamera瀵硅薄鍙傛暟
/// 32浣岖郴缁熶笅128瀛楄妭
/// \~english
/// \brief create GigE camera object's info object
/// 128 bytes in 32-bit system
typedef struct GENICAM_GigECameraInfo
{
	GENICAM_Camera*  pCamera;	///< \~chinese 鐩告満瀵硅薄    ///< \~english camera object
	uint32_t reserved[31];	    ///< \~chinese 淇濈暀        ///< \~english reserved field
} GENICAM_GigECameraInfo;

/// \~chinese
/// 鍒涘缓GiGE璁惧瀵硅薄
/// \param [in] pGigECameraInfo 鍒涘缓GiGE璁惧瀵硅薄镄勫弬鏁?
/// \param [out] ppGigECamera GigECamera 瀵硅薄
/// \retval < 0 鍒涘缓澶辫触
/// \retval 0   鍒涘缓鎴愬姛
/// \~english
/// create GigE camera object
/// \param [in]  pGigECameraInfo GigE camera info object
/// \param [out] ppGigECamera    GigE camera object
/// \retval < 0 create failed
/// \retval 0   create successfully
GENICAM_API int32_t CALL_METHOD GENICAM_createGigECamera(GENICAM_GigECameraInfo* pGigECameraInfo
													, GENICAM_GigECamera** ppGigECamera);
/// @}


/// \~chinese
/// \brief 鐩告満鎺ュ彛绫?
/// \defgroup GigEInterface  杩炴帴GigE鐩告満镄勬帴鍙?
/// @{
/// \~english
/// \brief camera interface 
/// \defgroup GigEInterface Interface Of GigEVision Camera Connection
/// @{
typedef struct GENICAM_GigEInterface
{
	/// \~chinese
	/// 搴曞眰绉佹湁鏁版嵁
	/// \~english
	/// Underlying private data
	void *priv;

	/// \~chinese
	/// 澧炲姞鎺ュ彛寮旷敤
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \~english
	/// add interface reference
	/// \param [in] thiz this pointer
	int32_t(*addRef)(struct GENICAM_GigEInterface *thiz);

	/// \~chinese
	/// 閲婃斁鎺ュ彛
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \~english
	/// release interface
	/// \param [in] thiz this pointer
	int32_t(*release)(struct GENICAM_GigEInterface *thiz);

	/// \~chinese
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖缃戝崱鎻忚堪淇℃伅锛屽け璐ヨ繑锲濶ULL
	/// \~english
	/// \param [in] thiz this pointer
	/// \return return network card description, return NULL if failed
	const char * (*getDescription)(struct GENICAM_GigEInterface *thiz);

	/// \~chinese
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖缃戝崱镄処P鍦板潃锛屽け璐ヨ繑锲濶ULL
	/// \~english
	/// \param [in] thiz this pointer
	/// \return return NIC's IpAddress, return NULL if failed
	const char * (*getIpAddress)(struct GENICAM_GigEInterface *thiz);

	/// \~chinese
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖缃戝崱镄勫瓙缃戞帺镰侊紝澶辫触杩斿洖NULL
	/// \~english
	/// \param [in] thiz this pointer
	/// \return return NIC's subnetMask, return NULL if failed
	const char * (*getSubnetMask)(struct GENICAM_GigEInterface *thiz);

	/// \~chinese
	/// \brief 杩斿洖缃戝崱镄勭綉鍏?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖缃戝崱镄勭綉鍏筹紝澶辫触杩斿洖NULL
	/// \~english
	/// \brief return Gateway
	/// \param [in] thiz this pointer
	/// \return return NIC's Gateway, return NULL if failed
	const char * (*getGateway)(struct GENICAM_GigEInterface *thiz);

	/// \~chinese
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖缃戝崱镄凪ac鍦板潃锛屽け璐ヨ繑锲濶ULL
	/// \~english
	/// \param [in] thiz this pointer
	/// \return return NIC's macAddress, return NULL if failed
	const char * (*getMacAddress)(struct GENICAM_GigEInterface *thiz);

	uint32_t reserve[24];					 ///< \~chinese 棰勭暀瀛楁    ///< \~english reserved field
}GENICAM_GigEInterface;

/// \~chinese
/// \brief 鍒涘缓GiGE璁惧鎺ュ彛瀵硅薄鍙傛暟
/// 32浣岖郴缁熶笅128瀛楄妭
/// \~english
/// \brief create GigE camera interface object 
/// 128 bytes in 32-bit system
typedef struct GENICAM_GigEInterfaceInfo
{
	GENICAM_Camera*  pCamera;	///< \~chinese 鐩告満瀵硅薄    ///< \~english camera object
	uint32_t reserved[31];	    ///< \~chinese 淇濈暀        ///< \~english reserved field
} GENICAM_GigEInterfaceInfo;

/// \~chinese
/// 鍒涘缓GiGE璁惧鎺ュ彛瀵硅薄
/// \param [in] pGigEInterfaceInfo 鍒涘缓GiGE璁惧瀵硅薄镄勫弬鏁?
/// \param [out] ppGigEInterface GigE Camera 镓€杩炴帴镄勬帴鍙ｅ璞?
/// \retval < 0 鍒涘缓澶辫触
/// \retval 0   鍒涘缓鎴愬姛
/// \~english
/// create GigE camera interface object
/// \param [in] pGigEInterfaceInfo parameter used to create GigE camera object
/// \param [out] ppGigEInterface interface ojbect which connect the GigE Camera
/// \retval < 0 create failed
/// \retval 0   create successfully
GENICAM_API int32_t CALL_METHOD GENICAM_createGigEInterface(GENICAM_GigEInterfaceInfo*pGigEInterfaceInfo
	, GENICAM_GigEInterface** ppGigEInterface);
/// @}



/// \~chinese
/// \brief 鐩告満瀵硅薄鎺ュ彛绫?
/// \defgroup GENICAM_UsbCamera  USB鐩告満瀵硅薄鎿崭綔鎺ュ彛
/// @{
/// \~english
/// \brief camera object interface class
/// \defgroup GENICAM_UsbCamera USB Camera Object Operation Interface
/// @{
/// \~chinese													
/// \brief USB鐩告満鐗规畩鎺ュ彛
/// 32浣岖郴缁熶笅128瀛楄妭
/// \~english
/// \brief USB camera specific object
/// 128 bytes in 32-bit system
typedef struct GENICAM_UsbCamera
{
	/// \~chinese
	/// 搴曞眰绉佹湁鏁版嵁
	/// \~english
	/// Underlying private data
	void *priv;

	/// \~chinese
	/// 澧炲姞鎺ュ彛寮旷敤
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \~english
	/// add interface reference
	/// \param [in] thiz this pointer
	int32_t(*addRef)(struct GENICAM_UsbCamera *thiz);

	/// \~chinese
	/// 閲婃斁鎺ュ彛
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \~english
	/// release interface
	/// \param [in] thiz this pointer
	int32_t(*release)(struct GENICAM_UsbCamera *thiz);

	/// \~chinese
	/// \brief 銮峰彇鐩告満镄?Configuration Valid
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖鐩告満镄?Configuration Valid锛屽け璐ヨ繑锲濶ULL
	/// \~english
	/// \brief get camera's Configuration Valid
	/// \param [in] thiz this pointer
	/// \return camera's Configuration Valid, return NULL if failed
	const char*  (*getConfigurationValid)(struct GENICAM_UsbCamera *thiz);

	/// \~chinese
	/// \brief 銮峰彇鐩告満镄?GenCP Version
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖鐩告満镄?GenCP Version锛屽け璐ヨ繑锲濶ULL
	/// \~english
	/// \brief get camera's GenCP Version
	/// \param [in] thiz this pointer
	/// \return camera's GenCP Version, return NULL if failed
	const char*  (*getGenCPVersion)(struct GENICAM_UsbCamera *thiz);

	/// \~chinese
	/// \brief 銮峰彇鐩告満镄?U3V Version
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖鐩告満镄?U3V Version锛屽け璐ヨ繑锲濶ULL
	/// \~english
	/// \brief get camera's U3V Version
	/// \param [in] thiz this pointer
	/// \return camera's U3V Version, return NULL if failed
	const char*  (*getU3VVersion)(struct GENICAM_UsbCamera *thiz);

	/// \~chinese
	/// \brief 銮峰彇鐩告満镄?Device GUID
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖鐩告満镄?Device GUID锛屽け璐ヨ繑锲濶ULL
	/// \~english
	/// \brief get camera's Device GUID
	/// \param [in] thiz this pointer
	/// \return camera's Device GUID, return NULL if failed
	const char*  (*getDeviceGUID)(struct GENICAM_UsbCamera *thiz);

	/// \~chinese
	/// \brief 銮峰彇鐩告満镄?Family Name
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖鐩告満镄?Family Name锛屽け璐ヨ繑锲濶ULL
	/// \~english
	/// \brief get camera's Family Name
	/// \param [in] thiz this pointer
	/// \return camera's Family Name, return NULL if failed
	const char*  (*getFamilyName)(struct GENICAM_UsbCamera *thiz);

	/// \~chinese
	/// \brief 銮峰彇鐩告満镄勫簭鍒楀佛
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖鐩告満镄勫簭鍒楀佛锛屽け璐ヨ繑锲濶ULL
	/// \~english
	/// \brief get camera's serial number
	/// \param [in] thiz this pointer
	/// \return camera's serial number, return NULL if failed
	const char*  (*getU3VSerialNumber)(struct GENICAM_UsbCamera *thiz);

	/// \~chinese
	/// \brief 鐩告満鏄惁鏀寔 Low Speed
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 0 鏀寔, -1 涓嶆敮鎸?
	/// \~english
	/// \brief if Low Speed is supported
	/// \param [in] thiz this pointer
	/// \return 0 if supported, return -1 if not supported
	int32_t (*isLowSpeedSupported)(struct GENICAM_UsbCamera *thiz);
	
	/// \~chinese
	/// \brief 鐩告満鏄惁鏀寔 Full Speed
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 0 鏀寔, -1 涓嶆敮鎸?
	/// \~english
	/// \brief if Full Speed is supported
	/// \param [in] thiz this pointer
	/// \return 0 if supported, return -1 if not supported
	int32_t (*isFullSpeedSupported)(struct GENICAM_UsbCamera *thiz);

	/// \~chinese
	/// \brief 鐩告満鏄惁鏀寔 High Speed
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 0 鏀寔, -1 涓嶆敮鎸?
	/// \~english
	/// \brief if High Speed is supported
	/// \param [in] thiz this pointer
	/// \return 0 if supported, return -1 if not supported
	int32_t (*isHighSpeedSupported)(struct GENICAM_UsbCamera *thiz);

	/// \~chinese
	/// \brief 鐩告満鏄惁鏀寔 Super Speed
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 0 鏀寔, -1 涓嶆敮鎸?
	/// \~english
	/// \brief if Super Speed is supported
	/// \param [in] thiz this pointer
	/// \return 0 if supported, return -1 if not supported
	int32_t (*isSuperSpeedSupported)(struct GENICAM_UsbCamera *thiz);

	/// \~chinese
	/// \brief 銮峰彇鐩告満镄?Speed
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖鐩告満镄?Speed锛屽け璐ヨ繑锲濶ULL
	/// \~english
	/// \brief get camera's Speed
	/// \param [in] thiz this pointer
	/// \return camera's Speed, return NULL if failed
	const char*  (*getSpeed)(struct GENICAM_UsbCamera *thiz);

	/// \~chinese
	/// \brief 銮峰彇鐩告満镄?Max Power
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖鐩告満镄?Max Power锛屽け璐ヨ繑锲濶ULL
	/// \~english
	/// \brief get camera's Max Power
	/// \param [in] thiz this pointer
	/// \return camera's Max Power, return NULL if failed
	const char*  (*getMaxPower)(struct GENICAM_UsbCamera *thiz);

	/// \~chinese
	/// \brief 鏄惁瀹夎浜哢SB椹卞姩
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 0 瀹夎浜哢SB椹卞姩锛?1 娌℃湁瀹夎USB椹卞姩
	/// \~english
	/// \brief if USB driver is installed
	/// \param [in] thiz this pointer
	/// \return 0 if installed, return -1 if not installed
	int32_t (*isDriverInstalled)(struct GENICAM_UsbCamera *thiz);

	uint32_t reserve[16];					 ///< \~chinese 棰勭暀瀛楁    ///< \~english reserved field
}GENICAM_UsbCamera;

/// \~chinese
/// \brief 鍒涘缓UsbCamera瀵硅薄鍙傛暟
/// 32浣岖郴缁熶笅128瀛楄妭
/// \~english
/// \brief create Usb camera object's info object
/// 128 bytes in 32-bit system
typedef struct GENICAM_UsbCameraInfo
{
	GENICAM_Camera*  pCamera;	///< \~chinese 鐩告満瀵硅薄    ///< \~english camera object
	uint32_t reserved[31];	    ///< \~chinese 淇濈暀        ///< \~english reserved field
} GENICAM_UsbCameraInfo;

/// \~chinese
/// 鍒涘缓USB璁惧瀵硅薄
/// \param [in] pUsbCameraInfo 鍒涘缓USB璁惧瀵硅薄镄勫弬鏁?
/// \param [out] ppUsbCamera UsbCamera 瀵硅薄
/// \retval < 0 鍒涘缓澶辫触
/// \retval 0   鍒涘缓鎴愬姛
/// \~english
/// create USB camera object
/// \param [in]  pUsbCameraInfo USB camera info object
/// \param [out] ppUsbCamera    USB camera object
/// \retval < 0 create failed
/// \retval 0   create successfully
GENICAM_API int32_t CALL_METHOD GENICAM_createUsbCamera(GENICAM_UsbCameraInfo* pUsbCameraInfo
	, GENICAM_UsbCamera** ppUsbCamera);
/// @}



/// \~chinese
/// \brief 鐩告満鎺ュ彛绫?
/// \defgroup UsbInterface  杩炴帴USB鐩告満镄勬帴鍙?
/// \~english
/// \brief camera interface 
/// \defgroup UsbInterface Interface Of USB Camera Connection
/// @{
typedef struct GENICAM_UsbInterface
{
	/// \~chinese
	/// 搴曞眰绉佹湁鏁版嵁
	/// \~english
	/// Underlying private data
	void *priv;

	/// \~chinese
	/// 澧炲姞鎺ュ彛寮旷敤
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \~english
	/// add interface reference
	/// \param [in] thiz this pointer
	int32_t(*addRef)(struct GENICAM_UsbInterface *thiz);

	/// \~chinese
	/// 閲婃斁鎺ュ彛
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \~english
	/// release interface
	/// \param [in] thiz this pointer
	int32_t(*release)(struct GENICAM_UsbInterface *thiz);

	/// \~chinese
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖鎻忚堪淇℃伅锛屽け璐ヨ繑锲濶ULL
	/// \~english
	/// \param [in] thiz this pointer
	/// \return return description, return NULL if failed
	const char * (*getDescription)(struct GENICAM_UsbInterface *thiz);

	/// \~chinese
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖 Vendor ID锛屽け璐ヨ繑锲濶ULL
	/// \~english
	/// \param [in] thiz this pointer
	/// \return return Vendor ID, return NULL if failed
	const char * (*getVendorID)(struct GENICAM_UsbInterface *thiz);

	/// \~chinese
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖 Device ID锛屽け璐ヨ繑锲濶ULL
	/// \~english
	/// \param [in] thiz this pointer
	/// \return return Device ID, return NULL if failed
	const char * (*getDeviceID)(struct GENICAM_UsbInterface *thiz);

	/// \~chinese
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖 Subsystem ID锛屽け璐ヨ繑锲濶ULL
	/// \~english
	/// \param [in] thiz this pointer
	/// \return return Subsystem ID, return NULL if failed
	const char * (*getSubsystemID)(struct GENICAM_UsbInterface *thiz);

	/// \~chinese
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖 Revision锛屽け璐ヨ繑锲濶ULL
	/// \~english
	/// \param [in] thiz this pointer
	/// \return return Revision, return NULL if failed
	const char * (*getRevision)(struct GENICAM_UsbInterface *thiz);

	/// \~chinese
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖鎺ュ彛镄剆peed锛屽け璐ヨ繑锲濶ULL
	/// \~english
	/// \param [in] thiz this pointer
	/// \return return speed of interface, return NULL if failed
	const char * (*getSpeed)(struct GENICAM_UsbInterface *thiz);

	uint32_t reserve[23];					 ///< \~chinese 棰勭暀瀛楁    ///< \~english reserved field
}GENICAM_UsbInterface;

/// \~chinese
/// \brief 鍒涘缓USB璁惧鎺ュ彛瀵硅薄鍙傛暟
/// 32浣岖郴缁熶笅128瀛楄妭
/// \~english
/// \brief create USB camera interface object 
/// 128 bytes in 32-bit system
typedef struct GENICAM_UsbInterfaceInfo
{
	GENICAM_Camera*  pCamera;	///< \~chinese 鐩告満瀵硅薄    ///< \~english camera object
	uint32_t reserved[31];	    ///< \~chinese 淇濈暀        ///< \~english reserved field
} GENICAM_UsbInterfaceInfo;

/// \~chinese
/// 鍒涘缓USB璁惧鎺ュ彛瀵硅薄
/// \param [in] pUsbInterfaceInfo 鍒涘缓USB璁惧瀵硅薄镄勫弬鏁?
/// \param [out] ppUsbInterface Usb Camera 镓€杩炴帴镄勬帴鍙ｅ璞?
/// \retval < 0 鍒涘缓澶辫触
/// \retval 0   鍒涘缓鎴愬姛
/// \~english
/// create USB camera interface object
/// \param [in] pUsbInterfaceInfo parameter used to create Usb camera object
/// \param [out] ppUsbInterface interface ojbect which connect the Usb Camera
/// \retval < 0 create failed
/// \retval 0   create successfully
GENICAM_API int32_t CALL_METHOD GENICAM_createUsbInterface(GENICAM_UsbInterfaceInfo*pUsbInterfaceInfo
									, GENICAM_UsbInterface** ppUsbInterface);
/// @}


// 閰岖疆鍙傛暟鐩稿叧镄勬帴鍙?

/// \~chinese
/// \brief 甯哥敤鍙傛暟瀵硅薄鎺ュ彛
/// \defgroup config 灞炴€ч厤缃浉鍏虫搷浣沧帴鍙?
/// @{
/// \~english
/// \brief common parameter object interface
/// \defgroup config Property Configure Operation Interface 
/// @{

/// \~chinese
/// \brief Class GENICAM_IntNode 鏁村瀷灞炴€ф搷浣灭被
/// 32浣岖郴缁熶笅128瀛楄妭
/// \~english
/// \brief Integer property operation class
/// 128 bytes in 32-bit system
typedef struct GENICAM_IntNode
{
	/// \~chinese
	/// 搴曞眰绉佹湁鏁版嵁
	/// \~english
	/// Underlying private data
	void *priv;

	/// \~chinese
	/// 澧炲姞鎺ュ彛寮旷敤
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \~english
	/// add interface reference
	/// \param [in] thiz this pointer
	int32_t (*addRef)(struct GENICAM_IntNode *thiz);

	/// \~chinese
	/// 閲婃斁鎺ュ彛
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \~english
	/// release interface
	/// \param [in] thiz this pointer
	int32_t (*release)(struct GENICAM_IntNode *thiz);

	/// \~chinese
	/// \brief 銮峰彇灞炴€у€?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \param [out] pVal 銮峰彇鍒扮殑灞炴€у€?
	/// \return 鎴愬姛杩斿洖0锛屽け璐ヨ繑锲?1
	/// \~english
	/// \brief get property's value
	/// \param [in] thiz this pointer
	/// \param [out] pVal the property value
	/// \return success:0, fail:-1
	int32_t (*getValue)(struct GENICAM_IntNode *thiz, int64_t* pVal);

	/// \~chinese
	/// \brief 璁剧疆灞炴€у€?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \param [in] val 寰呰缃殑灞炴€у€?
	/// \return 鎴愬姛杩斿洖0锛屽け璐ヨ繑锲?1
	/// \~english
	/// \brief set the property's value
	/// \param [in] thiz this pointer
	/// \param [in] val the value to be set for this property
	/// \return success:0, fail:-1
	int32_t (*setValue)(struct GENICAM_IntNode *thiz, int64_t val);

	/// \~chinese
	/// \brief 銮峰彇灞炴€у彲璁炬渶灏忓€?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \param [out] pMinVal 銮峰彇鍒扮殑灞炴€ф渶灏忓€?
	/// \return 鎴愬姛杩斿洖0锛屽け璐ヨ繑锲?1
	/// \~english
	/// \brief get the property's minimum value that can be set
	/// \param [in] thiz this pointer
	/// \param [out] pMinVal the property's minimum value
	/// \return success:0, fail:-1
	int32_t (*getMinVal)(struct GENICAM_IntNode *thiz, int64_t* pMinVal);

	/// \~chinese
	/// \brief 銮峰彇灞炴€у彲璁炬渶澶у€?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \param [out] pMaxVal 銮峰彇鍒扮殑灞炴€ф渶澶у€?
	/// \return 鎴愬姛杩斿洖0锛屽け璐ヨ繑锲?1
	/// \~english
	/// \brief get the property's maximum value that can be set
	/// \param [in] thiz this pointer
	/// \param [out] pMaxVal the property's maximum value
	/// \return success:0, fail:-1
	int32_t (*getMaxVal)(struct GENICAM_IntNode *thiz, int64_t* pMaxVal);

	/// \~chinese
	/// \brief 鍒ゆ柇灞炴€ф槸鍚︽湁鏁?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 0琛ㄧず链夋晥锛?1琛ㄧず镞犳晥
	/// \~english
	/// \brief check the property is available or not
	/// \param [in] thiz this pointer
	/// \return valid:0, invalid:-1
	int32_t (*isValid)(struct GENICAM_IntNode *thiz);

	/// \~chinese
	/// \brief 鍒ゆ柇灞炴€ф槸鍚﹀彲鐢?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 0琛ㄧず鍙敤锛?1琛ㄧず涓嶅彲鐢?
	/// \~english
	/// \brief check the property is available or not
	/// \param [in] thiz this pointer
	/// \return available:0, not available:-1
	int32_t(*isAvailable)(struct GENICAM_IntNode *thiz);

	/// \~chinese
	/// \brief 鍒ゆ柇灞炴€ф槸鍚﹀彲璇?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 0琛ㄧず鍙锛?1琛ㄧず涓嶅彲璇?
	/// \~english
	/// \brief check the property is readable or not
	/// \param [in] thiz this pointer
	/// \return readable:0, not readable:-1
	int32_t(*isReadable)(struct GENICAM_IntNode *thiz);

	/// \~chinese
	/// \brief 鍒ゆ柇灞炴€ф槸鍚﹀彲鍐?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 0琛ㄧず鍙啓锛?1琛ㄧず涓嶅彲鍐?
	/// \~english
	/// \brief check the property is writeable or not
	/// \param [in] thiz this pointer
	/// \return writeable:0, not writeable:-1
	int32_t(*isWriteable)(struct GENICAM_IntNode *thiz);

	/// \~chinese
	/// \brief 銮峰彇灞炴€ф闀?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \param [out] pVal 銮峰彇鍒扮殑灞炴€ф闀?
	/// \return 鎴愬姛杩斿洖0锛屽け璐ヨ繑锲?1
	/// \~english
	/// \brief get property's increment
	/// \param [in] thiz this pointer
	/// \param [out] pVal the property increment
	/// \return success:0, fail:-1
	int32_t(*getIncrement)(struct GENICAM_IntNode *thiz, int64_t* pVal);

	uint32_t reserve[20];					 ///< \~chinese 棰勭暀瀛楁    ///< \~english reserved field

}GENICAM_IntNode;


/// \~chinese
/// \brief 鍒涘缓鏁存暟鑺傜偣绫诲瀷淇℃伅
/// 32浣岖郴缁熶笅128 + 1024 瀛楄妭
/// \~english
/// \brief create int node type's info
/// 128 + 1024  bytes in 32-bit system
typedef struct GENICAM_IntNodeInfo
{
	GENICAM_Camera* pCamera;	        ///< \~chinese 鐩告満瀵硅薄    ///< \~english camera object
	char attrName[MAX_ATTR_NAME_LEN];   ///< \~chinese 灞炴€у悕绉?   ///< \~english attribute name
	uint32_t reserved[31];	            ///< \~chinese 淇濈暀        ///< \~english reserved field
} GENICAM_IntNodeInfo;

/// \~chinese
/// 鍒涘缓鏁存暟鑺傜偣绫诲瀷瀵硅薄
/// \param [in] pIntNodeInfo 鍒涘缓鏁存暟鑺傜偣绫诲瀷淇℃伅
/// \param [out] ppIntNode   鏁存暟绫诲瀷瀵硅薄
/// \retval < 0 鍒涘缓澶辫触
/// \retval 0   鍒涘缓鎴愬姛
/// \~english
/// create IntNode property object class
/// \param [in]  pIntNodeInfo create IntNode info
/// \param [out] ppIntNode    IntNode type object
/// \retval < 0 create failed
/// \retval 0   create successfully
GENICAM_API int32_t CALL_METHOD GENICAM_createIntNode(GENICAM_IntNodeInfo* pIntNodeInfo
	, GENICAM_IntNode** ppIntNode);


/// \~chinese
/// \brief Class GENICAM_DoubleNode 娴偣鏁板睘镐ф搷浣灭被
/// 32浣岖郴缁熶笅128瀛楄妭
/// \~english
/// \brief Float property operation class
/// 128 bytes in 32-bit system
typedef struct GENICAM_DoubleNode
{
	/// \~chinese
	/// 搴曞眰绉佹湁鏁版嵁
	/// \~english
	/// Underlying private data
	void *priv;

	/// \~chinese
	/// 澧炲姞鎺ュ彛寮旷敤
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \~english
	/// add interface reference
	/// \param [in] thiz this pointer
	int32_t (*addRef)(struct GENICAM_DoubleNode *thiz);

	/// \~chinese
	/// 閲婃斁鎺ュ彛
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \~english
	/// release interface
	/// \param [in] thiz this pointer
	int32_t (*release)(struct GENICAM_DoubleNode *thiz);

	/// \~chinese
	/// \brief 銮峰彇灞炴€у€?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \param [out] pVal 銮峰彇鍒扮殑灞炴€у€?
	/// \return 鎴愬姛杩斿洖0锛屽け璐ヨ繑锲?1
	/// \~english
	/// \brief get property's value
	/// \param [in] thiz this pointer
	/// \param [out] pVal the property's value
	/// \return success:0, fail:-1
	int32_t (*getValue)(struct GENICAM_DoubleNode *thiz, double* pVal);

	/// \~chinese
	/// \brief 璁剧疆灞炴€у€?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \param [in] val 寰呰缃殑灞炴€у€?
	/// \return 鎴愬姛杩斿洖0锛屽け璐ヨ繑锲?1
	/// \~english
	/// \brief set property's value
	/// \param [in] thiz this pointer
	/// \param [in] val the value to be set for this property
	/// \return success:0, fail:-1
	int32_t (*setValue)(struct GENICAM_DoubleNode *thiz, double val);

	/// \~chinese
	/// \brief 銮峰彇灞炴€у彲璁炬渶灏忓€?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \param [out] pMinVal 銮峰彇鍒扮殑灞炴€ф渶灏忓€?
	/// \return 鎴愬姛杩斿洖0锛屽け璐ヨ繑锲?1
	/// \~english
	/// \brief get the property's minimum value that can be set
	/// \param [in] thiz this pointer
	/// \param [out] pMinVal the property's minimum value
	/// \return success:0, fail:-1
	int32_t (*getMinVal)(struct GENICAM_DoubleNode *thiz, double* pMinVal);

	/// \~chinese
	/// \brief 銮峰彇灞炴€у彲璁炬渶澶у€?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \param [out] pMaxVal 銮峰彇鍒扮殑灞炴€ф渶澶у€?
	/// \return 鎴愬姛杩斿洖0锛屽け璐ヨ繑锲?1
	/// \~english
	/// \brief get the property's maximum value that can be set
	/// \param [in] thiz this pointer
	/// \param [out] pMaxVal the property's maximum value
	/// \return success:0, fail:-1
	int32_t (*getMaxVal)(struct GENICAM_DoubleNode *thiz, double* pMaxVal);

	/// \~chinese
	/// \brief 鍒ゆ柇灞炴€ф槸鍚︽湁鏁?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 0琛ㄧず链夋晥锛?1琛ㄧず镞犳晥
	/// \~english
	/// \brief check the property is valid or not
	/// \param [in] thiz this pointer
	/// \return valid:0, invalid:-1
	int32_t (*isValid)(struct GENICAM_DoubleNode *thiz);

	/// \~chinese
	/// \brief 鍒ゆ柇灞炴€ф槸鍚﹀彲鐢?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 0琛ㄧず鍙敤锛?1琛ㄧず涓嶅彲鐢?
	/// \~english
	/// \brief check the property is available or not
	/// \param [in] thiz this pointer
	/// \return available:0, not available:-1
	int32_t(*isAvailable)(struct GENICAM_DoubleNode *thiz);

	/// \~chinese
	/// \brief 鍒ゆ柇灞炴€ф槸鍚﹀彲璇?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 0琛ㄧず鍙锛?1琛ㄧず涓嶅彲璇?
	/// \~english
	/// \brief check the property is readable or not
	/// \param [in] thiz this pointer
	/// \return readable:0, not readable:-1
	int32_t(*isReadable)(struct GENICAM_DoubleNode *thiz);

	/// \~chinese
	/// \brief 鍒ゆ柇灞炴€ф槸鍚﹀彲鍐?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 0琛ㄧず鍙啓锛?1琛ㄧず涓嶅彲鍐?
	/// \~english
	/// \brief check the property is writeable or not
	/// \param [in] thiz this pointer
	/// \return writeable:0, not writeable:-1
	int32_t(*isWriteable)(struct GENICAM_DoubleNode *thiz);

	uint32_t reserve[21];					 ///< \~chinese 棰勭暀瀛楁    ///< \~english reserved field

}GENICAM_DoubleNode;


/// \~chinese
/// \brief 鍒涘缓娴偣鏁拌妭镣圭被鍨嬩俊鎭?
/// 32浣岖郴缁熶笅128 + 1024 瀛楄妭
/// \~english
/// \brief create double node info
/// 128 + 1024 bytes in 32-bit system
typedef struct GENICAM_DoubleNodeInfo
{
	GENICAM_Camera* pCamera;	        ///< \~chinese 鐩告満瀵硅薄    ///< \~english camera object
	char attrName[MAX_ATTR_NAME_LEN];   ///< \~chinese 灞炴€у悕绉?   ///< \~english property's name
	uint32_t reserved[31];	            ///< \~chinese 淇濈暀        ///< \~english reserved field
} GENICAM_DoubleNodeInfo;

/// \~chinese
/// 鍒涘缓娴偣鏁拌妭镣圭被鍨嫔璞?
/// \param [in]  pDoubleNodeInfo 鍒涘缓娴偣鏁拌妭镣圭被鍨嬩俊鎭?
/// \param [out] ppDoubleNode   娴偣鏁扮被鍨嫔璞?
/// \retval < 0 鍒涘缓澶辫触
/// \retval 0   鍒涘缓鎴愬姛
/// \~english
/// create double node object
/// \param [in]  pDoubleNodeInfo create double node info
/// \param [out] ppDoubleNode    double node object
/// \retval < 0 create failed
/// \retval 0   create successfully
GENICAM_API int32_t CALL_METHOD GENICAM_createDoubleNode(GENICAM_DoubleNodeInfo* pDoubleNodeInfo
	, GENICAM_DoubleNode** ppDoubleNode);

/// \~chinese
/// \brief Class GENICAM_EnumNode 鏋氢妇鍨嫔睘镐ф搷浣灭被
/// 32浣岖郴缁熶笅128瀛楄妭
/// \~english
/// \brief EnumNode property operation class
/// 128 bytes in 32-bit system
typedef struct GENICAM_EnumNode
{
	/// \~chinese
	/// 搴曞眰绉佹湁鏁版嵁
	/// \~english
	/// Underlying private data
	void *priv;

	/// \~chinese
	/// 澧炲姞鎺ュ彛寮旷敤
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \~english
	/// add interface reference
	/// \param [in] thiz this pointer
	int32_t (*addRef)(struct GENICAM_EnumNode *thiz);

	/// \~chinese
	/// 閲婃斁鎺ュ彛
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \~english
	/// release interface
	/// \param [in] thiz this pointer
	int32_t (*release)(struct GENICAM_EnumNode *thiz);

	/// \~chinese
	/// \brief 銮峰彇鏋氢妇灞炴€ymbol链?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \param [in/out] pVal  銮峰彇鍒扮殑灞炴€у€?绾﹀畾瀛楃涓查昵搴︽渶澶т负256锛岃鍐呭瓨鐢卞閮ㄥ垎閰?
	/// \param [in/out] pMaxCnt 杈揿叆镄勫瓧绗︿覆闀垮害锛屽嚭鍙傛椂涓哄疄闄呯殑瀛楃涓查昵搴?
	/// \return 鎴愬姛杩斿洖0锛屽け璐ヨ繑锲?1
	/// \~english
	/// \brief get enum property symbol's value
	/// \param [in] thiz this pointer
	/// \param [in/out] pVal  the length of property's value cannot exceed 256, this memory is also allocated externally
	/// \param [in/out] pMaxCnt the length of input chars; actual length of chars when output
	/// \return success:0, fail:-1
	int32_t (*getValueSymbol)(struct GENICAM_EnumNode *thiz, char* pVal, uint32_t *pMaxCnt);

	/// \~chinese
	/// \brief 璁剧疆鏋氢妇灞炴€ymbol链?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \param [in] strSymbolName 寰呰缃殑灞炴€у€?
	/// \return 鎴愬姛杩斿洖0锛屽け璐ヨ繑锲?1
	/// \~english
	/// \brief set enum property symbol's value
	/// \param [in] thiz this pointer
	/// \param [in] strSymbolName the value waiting to be set for this property
	/// \return success:0, fail:-1
	int32_t (*setValueBySymbol)(struct GENICAM_EnumNode *thiz,const char* strSymbolName);

	/// \~chinese
	/// \brief 銮峰彇鏋氢妇灞炴€у彲璁剧疆镄剆ymbol链煎垪琛?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \param [out] symbolList  銮峰彇鍒扮殑鍙缃殑symbol链煎垪琛紝瀛楃闀垮害链€闀夸负256.渚嫔:char symbolList[12][256]
	/// \param [in/out] pSymbolCnt in:鐢宠镄勭紦鍐叉暟閲?褰扑綔涓鸿緭鍏ュ弬鏁版椂锛屼笌symbolList镄勪竴缁翠釜鏁颁竴镊达紝链€澶氢负1000; out:銮峰彇鍒扮殑鍙缃殑symbol涓暟.
	/// \return 杩斿洖灞炴€у綋鍓嶅彲璁剧疆symbol链煎垪琛?
	/// \~english
	/// \brief Get the list of Enum property symbol value which can be set
	/// \param [in] thiz this pointer
	/// \param [out] symbolList  get the configurable symbol's value list, maximum length of chars is 256.For example:char symbolList[12][256]
	/// \param [in/out] pSymbolCnt in:buffer count is equal to the number of one dimension in symbolList; out:get the number of configurable symbol's value list, maximum number is 1000
	/// \return Return the list of Enum property symbol value which can be set now
	int32_t(*getEnumSymbolList)(struct GENICAM_EnumNode *thiz, char symbolList[][256], uint32_t *pSymbolCnt);

	/// \~chinese
	/// \brief 鍒ゆ柇灞炴€ф槸鍚︽湁鏁?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 0琛ㄧず链夋晥锛?1琛ㄧず镞犳晥
	/// \~english
	/// \brief check the property is valid or not
	/// \param [in] thiz this pointer
	/// \return valid:0, invalid:-1
	int32_t (*isValid)(struct GENICAM_EnumNode *thiz);

	/// \~chinese
	/// \brief 鍒ゆ柇灞炴€ф槸鍚﹀彲鐢?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 0琛ㄧず鍙敤锛?1琛ㄧず涓嶅彲鐢?
	/// \~english
	/// \brief check the property is available or not
	/// \param [in] thiz this pointer
	/// \return available:0, not available:-1
	int32_t(*isAvailable)(struct GENICAM_EnumNode *thiz);

	/// \~chinese
	/// \brief 鍒ゆ柇灞炴€ф槸鍚﹀彲璇?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 0琛ㄧず鍙锛?1琛ㄧず涓嶅彲璇?
	/// \~english
	/// \brief check the property is readable or not
	/// \param [in] thiz this pointer
	/// \return readable:0, not readable:-1
	int32_t(*isReadable)(struct GENICAM_EnumNode *thiz);

	/// \~chinese
	/// \brief 鍒ゆ柇灞炴€ф槸鍚﹀彲鍐?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 0琛ㄧず鍙啓锛?1琛ㄧず涓嶅彲鍐?
	/// \~english
	/// \brief check the property is writeable or not
	/// \param [in] thiz this pointer
	/// \return writeable:0, not writeable:-1
	int32_t(*isWriteable)(struct GENICAM_EnumNode *thiz);

	uint32_t reserve[22];					 ///< \~chinese 棰勭暀瀛楁    ///< \~english reserved field

}GENICAM_EnumNode;


/// \~chinese
/// \brief 鍒涘缓鏋氢妇鑺傜偣绫诲瀷淇℃伅
/// 32浣岖郴缁熶笅128 + 1024 瀛楄妭
/// \~english
/// \brief create enum node info
/// 128 + 1024 bytes in 32-bit system
typedef struct GENICAM_EnumNodeInfo
{
	GENICAM_Camera* pCamera;	        ///< \~chinese 鐩告満瀵硅薄    ///< \~english camera object
	char attrName[MAX_ATTR_NAME_LEN];   ///< \~chinese 灞炴€у悕绉?   ///< \~english attribute name
	uint32_t reserved[31];	            ///< \~chinese 淇濈暀        ///< \~english reserved field
} GENICAM_EnumNodeInfo;

/// \~chinese
/// 鍒涘缓鏋氢妇鑺傜偣绫诲瀷瀵硅薄
/// \param [in]  pEnumNodeInfo 鍒涘缓鏋氢妇鑺傜偣绫诲瀷淇℃伅
/// \param [out] ppEnumNode    鏋氢妇绫诲瀷瀵硅薄
/// \retval < 0 鍒涘缓澶辫触
/// \retval 0   鍒涘缓鎴愬姛
/// \~english
/// create enum node type object
/// \param [in]  pEnumNodeInfo create enum node info
/// \param [out] ppEnumNode    enum node object
/// \retval < 0 create failed
/// \retval 0   create successfully
GENICAM_API int32_t CALL_METHOD GENICAM_createEnumNode(GENICAM_EnumNodeInfo* pEnumNodeInfo
	, GENICAM_EnumNode** ppEnumNode);


/// \~chinese
/// \brief Class GENICAM_BoolNode 甯冨皵鍨嫔睘镐ф搷浣灭被
/// 32浣岖郴缁熶笅128瀛楄妭
/// \~english
/// \brief Bool property operation class
/// 128 bytes in 32-bit system
typedef struct GENICAM_BoolNode
{
	/// \~chinese
	/// 搴曞眰绉佹湁鏁版嵁
	/// \~english
	/// Underlying private data
	void *priv;

	/// \~chinese
	/// 澧炲姞鎺ュ彛寮旷敤
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \~english
	/// add interface reference
	/// \param [in] thiz this pointer
	int32_t (*addRef)(struct GENICAM_BoolNode *thiz);

	/// \~chinese
	/// 閲婃斁鎺ュ彛
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \~english
	/// release interface
	/// \param [in] thiz this pointer
	int32_t (*release)(struct GENICAM_BoolNode *thiz);

	/// \~chinese
	/// \brief 銮峰彇灞炴€у€?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \param [out] pVal 銮峰彇鍒扮殑灞炴€у€?
	/// \return 鎴愬姛杩斿洖0锛屽け璐ヨ繑锲?1
	/// \~english
	/// \brief get property's value
	/// \param [in] thiz this pointer
	/// \param [out] pVal property's value 
	/// \return success:0, fail:-1
	int32_t (*getValue)(struct GENICAM_BoolNode *thiz,uint32_t *pVal);

	/// \~chinese
	/// \brief 璁剧疆灞炴€у€?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \param [in] val 寰呰缃殑灞炴€у€?
	/// \return 鎴愬姛杩斿洖0锛屽け璐ヨ繑锲?1
	/// \~english
	/// \brief set the property'value 
	/// \param [in] thiz this pointer
	/// \param [in] val the value to be set for this property
	/// \return success:0, fail:-1	
	int32_t (*setValue)(struct GENICAM_BoolNode *thiz, uint32_t val);

	/// \~chinese
	/// \brief 鍒ゆ柇灞炴€ф槸鍚︽湁鏁?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 0琛ㄧず链夋晥锛?1琛ㄧず镞犳晥
	/// \~english
	/// \brief check the validity of this property
	/// \param [in] thiz this pointer
	/// \return valid:0, invalid:-1
	int32_t (*isValid)(struct GENICAM_BoolNode *thiz);

	/// \~chinese
	/// \brief 鍒ゆ柇灞炴€ф槸鍚﹀彲鐢?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 0琛ㄧず鍙敤锛?1琛ㄧず涓嶅彲鐢?
	/// \~english
	/// \brief check the property is available or not
	/// \param [in] thiz this pointer
	/// \return available:0, not available:-1
	int32_t(*isAvailable)(struct GENICAM_BoolNode *thiz);

	/// \~chinese
	/// \brief 鍒ゆ柇灞炴€ф槸鍚﹀彲璇?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 0琛ㄧず鍙锛?1琛ㄧず涓嶅彲璇?
	/// \~english
	/// \brief check the property is readable or not
	/// \param [in] thiz this pointer
	/// \return readable:0, not readable:-1
	int32_t(*isReadable)(struct GENICAM_BoolNode *thiz);

	/// \~chinese
	/// \brief 鍒ゆ柇灞炴€ф槸鍚﹀彲鍐?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 0琛ㄧず鍙啓锛?1琛ㄧず涓嶅彲鍐?
	/// \~english
	/// \brief check the property is writeable or not
	/// \param [in] thiz this pointer
	/// \return writeable:0, not writeable:-1
	int32_t(*isWriteable)(struct GENICAM_BoolNode *thiz);

	uint32_t reserve[23];					 ///< \~chinese 棰勭暀瀛楁    ///< \~english reserved field

}GENICAM_BoolNode;


/// \~chinese
/// \brief 鍒涘缓甯冨皵鑺傜偣绫诲瀷淇℃伅
/// 32浣岖郴缁熶笅128 + 1024 瀛楄妭
/// \~english
/// \brief create bool node info
/// 128 + 1024 bytes in 32-bit system
typedef struct GENICAM_BoolNodeInfo
{
	GENICAM_Camera* pCamera;	        ///< \~chinese 鐩告満瀵硅薄    ///< \~english camera object
	char attrName[MAX_ATTR_NAME_LEN];   ///< \~chinese 灞炴€у悕绉?   ///< \~english attribute name
	uint32_t reserved[31];	            ///< \~chinese 淇濈暀        ///< \~english reserved field
} GENICAM_BoolNodeInfo;

/// \~chinese
/// 鍒涘缓甯冨皵鑺傜偣绫诲瀷瀵硅薄
/// \param [in]  pBoolNodeInfo 鍒涘缓甯冨皵鑺傜偣绫诲瀷淇℃伅
/// \param [out] ppBoolNode    甯冨皵绫诲瀷瀵硅薄
/// \retval < 0 鍒涘缓澶辫触
/// \retval 0   鍒涘缓鎴愬姛
/// \~english
/// create Bool node object
/// \param [in]  pBoolNodeInfo create bool node info
/// \param [out] ppBoolNode    bool node object
/// \retval < 0 create failed
/// \retval 0   create successfully
GENICAM_API int32_t CALL_METHOD GENICAM_createBoolNode(GENICAM_BoolNodeInfo* pBoolNodeInfo
	, GENICAM_BoolNode** ppBoolNode);


/// \~chinese
/// \brief 锻戒护鍨嫔睘镐ф搷浣灭被
/// 32浣岖郴缁熶笅128瀛楄妭
/// \~english
/// \brief CmdNode property operation class
/// 128 bytes in 32-bit system
typedef struct GENICAM_CmdNode
{
	/// \~chinese
	/// 搴曞眰绉佹湁鏁版嵁
	/// \~english
	/// Underlying private data
	void *priv;

	/// \~chinese
	/// 澧炲姞鎺ュ彛寮旷敤
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \~english
	/// add interface reference
	/// \param [in] thiz this pointer
	int32_t (*addRef)(struct GENICAM_CmdNode *thiz);

	/// \~chinese
	/// 閲婃斁鎺ュ彛
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \~english
	/// release interface
	/// \param [in] thiz this pointer
	int32_t (*release)(struct GENICAM_CmdNode *thiz);

	/// \~chinese
	/// \brief 镓ц锻戒护绫诲瀷灞炴€?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 鎴愬姛杩斿洖0锛屽け璐ヨ繑锲?1
	/// \~english 
	/// \brief execute command property
	/// \param [in] thiz this pointer
	/// \return success:0, fail:-1
	int32_t (*execute)(struct GENICAM_CmdNode *thiz);

	/// \~chinese
	/// \brief 鍒ゆ柇灞炴€ф槸鍚︽湁鏁?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 0琛ㄧず链夋晥锛?1琛ㄧず镞犳晥
	/// \~english
	/// \brief check validity of the property
	/// \param [in] thiz this pointer
	/// \return valid:0, invalid:-1
	int32_t (*isValid)(struct GENICAM_CmdNode *thiz);

	/// \~chinese
	/// \brief 鍒ゆ柇灞炴€ф槸鍚﹀彲鐢?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 0琛ㄧず鍙敤锛?1琛ㄧず涓嶅彲鐢?
	/// \~english
	/// \brief check the property is available or not
	/// \param [in] thiz this pointer
	/// \return available:0, not available:-1
	int32_t (*isAvailable)(struct GENICAM_CmdNode *thiz);

	/// \~chinese
	/// \brief 鍒ゆ柇灞炴€ф槸鍚﹀彲璇?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 0琛ㄧず鍙锛?1琛ㄧず涓嶅彲璇?
	/// \~english
	/// \brief check the property is readable or not
	/// \param [in] thiz this pointer
	/// \return readable:0, not readable:-1
	int32_t(*isReadable)(struct GENICAM_CmdNode *thiz);

	/// \~chinese
	/// \brief 鍒ゆ柇灞炴€ф槸鍚﹀彲鍐?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 0琛ㄧず鍙啓锛?1琛ㄧず涓嶅彲鍐?
	/// \~english
	/// \brief check the property is writeable or not
	/// \param [in] thiz this pointer
	/// \return writeable:0, not writeable:-1
	int32_t(*isWriteable)(struct GENICAM_CmdNode *thiz);

	uint32_t reserve[24];					 ///< \~chinese 棰勭暀瀛楁    ///< \~english reserved field

}GENICAM_CmdNode;

/// \~chinese
/// \brief 鍒涘缓锻戒护鑺傜偣绫诲瀷淇℃伅
/// 32浣岖郴缁熶笅128 + 1024 瀛楄妭
/// \~english
/// \brief create command node info
/// 128 + 1024 bytes in 32-bit system
typedef struct GENICAM_CmdNodeInfo
{
	GENICAM_Camera* pCamera;	        ///< \~chinese 鐩告満瀵硅薄    ///< \~english camera object
	char attrName[MAX_ATTR_NAME_LEN];   ///< \~chinese 灞炴€у悕绉?   ///< \~english attribute name
	uint32_t reserved[31];	            ///< \~chinese 淇濈暀        ///< \~english reserved field
} GENICAM_CmdNodeInfo;

/// \~chinese
/// 鍒涘缓锻戒护鑺傜偣绫诲瀷瀵硅薄
/// \param [in]  pCmdNodeInfo 鍒涘缓锻戒护鑺傜偣绫诲瀷淇℃伅
/// \param [out] ppCmdNode    锻戒护绫诲瀷瀵硅薄
/// \retval < 0 鍒涘缓澶辫触
/// \retval 0   鍒涘缓鎴愬姛
/// \~english
/// create command node object
/// \param [in]  pCmdNodeInfo create command node info
/// \param [out] ppCmdNode    command node object
/// \retval < 0 create failed
/// \retval 0   create successfully
GENICAM_API int32_t CALL_METHOD GENICAM_createCmdNode(GENICAM_CmdNodeInfo* pCmdNodeInfo
	, GENICAM_CmdNode** ppCmdNode);


/// \~chinese
/// \brief GENICAM_StringNode string灞炴€ф搷浣灭被
/// 32浣岖郴缁熶笅128瀛楄妭
/// \~english
/// \brief string property operation class
/// 128 bytes in 32-bit system
typedef struct GENICAM_StringNode
{
	/// \~chinese
	/// 搴曞眰绉佹湁鏁版嵁
	/// \~english
	/// Underlying private data
	void *priv;

	/// \~chinese
	/// 澧炲姞鎺ュ彛寮旷敤
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \~english
	/// add interface reference
	/// \param [in] thiz this pointer
	int32_t (*addRef)(struct GENICAM_StringNode *thiz);

	/// \~chinese
	/// 閲婃斁鎺ュ彛
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \~english
	/// release interface
	/// \param [in] thiz this pointer
	int32_t (*release)(struct GENICAM_StringNode *thiz);

	/// \~chinese
	/// \brief 銮峰彇灞炴€у€?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \param [in/out] pOutStr 銮峰彇鍒扮殑灞炴€у€硷紝绾﹀畾瀛楃链€澶ч昵搴︿负256,璇ュ唴瀛樼敱澶栭儴鍒嗛厤
	/// \param [in/out] pMaxCnt 鍏ュ弬镞朵负杈揿叆鍐呭瓨镄勯昵搴︼紝鍑哄弬镞朵负瀹为台镄勫瓧绗﹂昵搴?
	/// \return 鎴愬姛杩斿洖0锛屽惁鍒?1
	/// \~english
	/// \brief get property's value
	/// \param [in] thiz this pointer
	/// \param [in/out] pOutStr Get the property's value, and the length of char cannot exceed 256, this memory is allocated externally
	/// \param [in/out] pMaxCnt At input, it is the length of input memory; At output, it is the actual length of chars 
	/// \return success:0, fail:-1	
	int32_t (*getValue)(struct GENICAM_StringNode *thiz,char*pOutStr,uint32_t *pMaxCnt);

	/// \~chinese
	/// \brief 璁剧疆灞炴€у€?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \param [in] pInStr 寰呰緭鍏ョ殑灞炴€у€?
	/// \return 鎴愬姛鍒栾繑锲?锛屽惁鍒栾繑锲?1
	/// \~english
	/// \brief set the property
	/// \param [in] thiz this pointer
	/// \param [in] pInStr the value waiting to be input for this property
	/// \return success:0, fail:-1	
	int32_t (*setValue)(struct GENICAM_StringNode *thiz, const char *pInStr);

	/// \~chinese
	/// \brief 鍒ゆ柇灞炴€ф槸鍚︽湁鏁?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 0琛ㄧず链夋晥锛?1琛ㄧず镞犳晥
	/// \~english
	/// \brief check validity of the property
	/// \param [in] thiz this pointer
	/// \return valid:0, invalid:-1
	int32_t (*isValid)(struct GENICAM_StringNode *thiz);

	/// \~chinese
	/// \brief 鍒ゆ柇灞炴€ф槸鍚﹀彲鐢?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 0琛ㄧず鍙敤锛?1琛ㄧず涓嶅彲鐢?
	/// \~english
	/// \brief check the property is available or not
	/// \param [in] thiz this pointer
	/// \return available:0, not available:-1
	int32_t(*isAvailable)(struct GENICAM_StringNode *thiz);

	/// \~chinese
	/// \brief 鍒ゆ柇灞炴€ф槸鍚﹀彲璇?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 0琛ㄧず鍙锛?1琛ㄧず涓嶅彲璇?
	/// \~english
	/// \brief check the property is readable or not
	/// \param [in] thiz this pointer
	/// \return readable:0, not readable:-1
	int32_t(*isReadable)(struct GENICAM_StringNode *thiz);

	/// \~chinese
	/// \brief 鍒ゆ柇灞炴€ф槸鍚﹀彲鍐?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 0琛ㄧず鍙啓锛?1琛ㄧず涓嶅彲鍐?
	/// \~english
	/// \brief check the property is writeable or not
	/// \param [in] thiz this pointer
	/// \return writeable:0, not writeable:-1
	int32_t(*isWriteable)(struct GENICAM_StringNode *thiz);

	uint32_t reserve[23];					 ///< \~chinese 棰勭暀瀛楁    ///< \~english reserved field

}GENICAM_StringNode;


/// \~chinese
/// \brief 鍒涘缓瀛楃涓茶妭镣圭被鍨嬩俊鎭?
/// 32浣岖郴缁熶笅128 + 1024 瀛楄妭
/// \~english
/// \brief create string node info
/// 128 + 1024 bytes in 32-bit system
typedef struct GENICAM_StringNodeInfo
{
	GENICAM_Camera* pCamera;	        ///< \~chinese 鐩告満瀵硅薄    ///< \~english camera object
	char attrName[MAX_ATTR_NAME_LEN];   ///< \~chinese 灞炴€у悕绉?   ///< \~english attribute name
	uint32_t reserved[31];	            ///< \~chinese 淇濈暀        ///< \~english reserved field
} GENICAM_StringNodeInfo;

/// \~chinese
/// 鍒涘缓瀛楃涓茶妭镣圭被鍨嫔璞?
/// \param [in]  pStringNodeInfo 鍒涘缓瀛楃涓茶妭镣圭被鍨嬩俊鎭?
/// \param [out] ppStringNode    瀛楃涓茬被鍨嫔璞?
/// \retval < 0 鍒涘缓澶辫触
/// \retval 0   鍒涘缓鎴愬姛
/// \~english
/// create string node object
/// \param [in]  pStringNodeInfo create string node info
/// \param [out] ppStringNode    string node object
/// \retval < 0 create failed
/// \retval 0   create successfully
GENICAM_API int32_t CALL_METHOD GENICAM_createStringNode(GENICAM_StringNodeInfo* pStringNodeInfo
	, GENICAM_StringNode** ppStringNode);



/// \~chinese
/// \brief GENICAM_AcquisitionControl 涓嫔睘镐ф搷浣灭被
/// \~english
/// \brief AcquisitionControl's property operation class
typedef struct GENICAM_AcquisitionControl
{
	/// \~chinese
	/// 搴曞眰绉佹湁鏁版嵁
	/// \~english
	/// Underlying private data
	void *priv;

	/// \~chinese
	/// 澧炲姞鎺ュ彛寮旷敤
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \~english
	/// add interface reference
	/// \param [in] thiz this pointer
	int32_t(*addRef)(struct GENICAM_AcquisitionControl *thiz);

	/// \~chinese
	/// 閲婃斁鎺ュ彛
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \~english
	/// release interface
	/// \param [in] thiz this pointer
	int32_t(*release)(struct GENICAM_AcquisitionControl *thiz);

	/// \~chinese
	/// \brief 銮峰彇AcquisitionFrameCount灞炴€ф搷浣滃璞?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖灞炴€ф搷浣滃璞?澶辫触杩斿洖NULL
	/// \~english
	/// \brief get AcquisitionFrameCount's property operation object
	/// \param [in] thiz this pointer
	/// \return success:return property operation object, fail:return NULL
	GENICAM_IntNode (*acquisitionFrameCount)(struct GENICAM_AcquisitionControl *thiz);

	/// \~chinese
	/// \brief 銮峰彇AcquisitionFrameRate灞炴€ф搷浣滃璞?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖灞炴€ф搷浣滃璞?澶辫触杩斿洖NULL
	/// \~english
	/// \brief get AcquisitionFrameRate property's operation object
	/// \param [in] thiz this pointer
	/// \return success:return property operation object, fail:return NULL
	GENICAM_DoubleNode (*acquisitionFrameRate)(struct GENICAM_AcquisitionControl *thiz);


	/// \~chinese
	/// \brief 銮峰彇AcquisitionFrameRateEnable浣胯兘灞炴€ф搷浣滃璞?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖灞炴€ф搷浣滃璞?澶辫触杩斿洖NULL
	/// \~english
	/// \brief get AcquisitionFrameRateEnable property operation object
	/// \param [in] thiz this pointer
	/// \return success:return property operation object, fail:return NULL
	GENICAM_BoolNode(*acquisitionFrameRateEnable)(struct GENICAM_AcquisitionControl *thiz);


	/// \~chinese
	/// \brief 銮峰彇AcquisitionFrameRate灞炴€ф搷浣滃璞?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖灞炴€ф搷浣滃璞?澶辫触杩斿洖NULL
	/// \~english
	/// \brief get AcquisitionFrameRate property operation object
	/// \param [in] thiz this pointer
	/// \return success:return property operation object, fail:return NULL
	GENICAM_EnumNode (*acquisitionMode)(struct GENICAM_AcquisitionControl *thiz);

	/// \~chinese
	/// \brief 銮峰彇ExposureAuto灞炴€ф搷浣滃璞?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖灞炴€ф搷浣滃璞?澶辫触杩斿洖NULL
	/// \~english
	/// \brief get ExposureAuto property operation object
	/// \param [in] thiz this pointer
	/// \return success:return property operation object, fail:return NULL
	GENICAM_EnumNode (*exposureAuto)(struct GENICAM_AcquisitionControl *thiz);

	/// \~chinese
	/// \brief 銮峰彇ExposureMode灞炴€ф搷浣滃璞?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖灞炴€ф搷浣滃璞?澶辫触杩斿洖NULL
	/// \~english
	/// \brief get ExposureMode property operation object
	/// \param [in] thiz this pointer
	/// \return success:return property operation object, fail:return NULL
	GENICAM_EnumNode (*exposureMode)(struct GENICAM_AcquisitionControl *thiz);

	/// \~chinese
	/// \brief 銮峰彇ExposureTime灞炴€ф搷浣滃璞?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖灞炴€ф搷浣滃璞?澶辫触杩斿洖NULL
	/// \~english
	/// \brief get ExposureTime property operation object
	/// \param [in] thiz this pointer
	/// \return success:return property operation object, fail:return NULL
	GENICAM_DoubleNode (*exposureTime)(struct GENICAM_AcquisitionControl *thiz);

	/// \~chinese
	/// \brief 銮峰彇TriggerActivation灞炴€ф搷浣滃璞★紝璁剧疆瑙﹀彂涓婂崌娌夸笅闄嶆部
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖灞炴€ф搷浣滃璞?澶辫触杩斿洖NULL
	/// \~english
	/// \brief get TriggerActivation property operation object,set trigger as rising edge or falling edge
	/// \param [in] thiz this pointer
	/// \return success:return property operation object, fail:return NULL
	GENICAM_EnumNode (*triggerActivation)(struct GENICAM_AcquisitionControl *thiz);

	/// \~chinese
	/// \brief 銮峰彇TriggerDelay灞炴€ф搷浣滃璞★紝璁剧疆杞Е鍙戝欢镞?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖灞炴€ф搷浣滃璞?澶辫触杩斿洖NULL
	/// \~english
	/// \brief get TriggerDelay property operation object, set soft trigger delay
	/// \param [in] thiz this pointer
	/// \return success:return property operation object, fail:return NULL
	GENICAM_DoubleNode (*triggerDelay)(struct GENICAM_AcquisitionControl *thiz);

	/// \~chinese
	/// \brief 銮峰彇TriggerMode灞炴€ф搷浣滃璞?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖灞炴€ф搷浣滃璞?澶辫触杩斿洖NULL
	/// \~english
	/// \brief get TriggerMode property operation object
	/// \param [in] thiz this pointer
	/// \return success:return property operation object, fail:return NULL
	GENICAM_EnumNode (*triggerMode)(struct GENICAM_AcquisitionControl *thiz);

	/// \~chinese
	/// \brief 銮峰彇TriggerSelector灞炴€ф搷浣滃璞?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖灞炴€ф搷浣滃璞?澶辫触杩斿洖NULL
	/// \~english
	/// \brief get TriggerSelector property operation object
	/// \param [in] thiz this pointer
	/// \return success:return property operation object, fail:return NULL
	GENICAM_EnumNode (*triggerSelector)(struct GENICAM_AcquisitionControl *thiz);

	/// \~chinese
	/// \brief 銮峰彇TriggerSource灞炴€ф搷浣滃璞★紝璁剧疆鍐呴儴/澶栭儴瑙﹀彂
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖灞炴€ф搷浣滃璞?澶辫触杩斿洖NULL	
	/// \~english
	/// \brief get TriggerSource property operation object, set internal/external trigger
	/// \param [in] thiz this pointer
	/// \return success:return property operation object, fail:return NULL
	GENICAM_EnumNode (*triggerSource)(struct GENICAM_AcquisitionControl *thiz);

	/// \~chinese
	/// \brief 銮峰彇TriggerSoftware灞炴€ф搷浣滃璞★紝镓ц鍐呴儴杞Е鍙?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖灞炴€ф搷浣滃璞?澶辫触杩斿洖NULL
	/// \~english
	/// \brief get TriggerSoftware property operation object, execute internal soft trigger
	/// \param [in] thiz this pointer
	/// \return success:return property operation object, fail:return NULL
	GENICAM_CmdNode (*triggerSoftware)(struct GENICAM_AcquisitionControl *thiz);

	uint32_t reserve[17];					 ///< \~chinese 棰勭暀瀛楁    ///< \~english reserved field
}GENICAM_AcquisitionControl;

/// \~chinese
/// brief 鍒涘缓灞炴€ц妭镣笰cquisitionControl淇℃伅
/// 32浣岖郴缁熶笅128瀛楄妭
/// \~english
/// brief create parameter node AcquisitionControl info
/// 128 bytes in 32-bit system
typedef struct GENICAM_AcquisitionControlInfo
{
	GENICAM_Camera*  pCamera;	///< \~chinese 鐩告満瀵硅薄    ///< \~english camera object
	uint32_t reserved[31];	   	///< \~chinese 淇濈暀        ///< \~english reserved field
} GENICAM_AcquisitionControlInfo;

/// \~chinese
/// 鍒涘缓灞炴€ц妭镣笰cquisitionControl
/// \param [in]  pAcquisitionControlInfo 鍒涘缓灞炴€ц妭镣笰cquisitionControl瀵硅薄镄勫弬鏁?
/// \param [out] ppAcquisitionControl 灞炴€ц妭镣笰cquisitionControl瀵硅薄
/// \retval < 0 鍒涘缓澶辫触
/// \retval 0   鍒涘缓鎴愬姛
/// \~english
/// create parameter node : AcquisitionControl
/// \param [in]  pAcquisitionControlInfo create AcquisitionControl info
/// \param [out] ppAcquisitionControl    AcquisitionControl object
/// \retval < 0 create failed
/// \retval 0   create successfully
GENICAM_API int32_t CALL_METHOD GENICAM_createAcquisitionControl(GENICAM_AcquisitionControlInfo*pAcquisitionControlInfo,
																	GENICAM_AcquisitionControl** ppAcquisitionControl);

typedef enum GENICAM_EConfigSet 
{
	userSet1 = 1,			///< \~chinese 銆愯鍐欍€戠浉链洪厤缃泦鍚?    ///< \~english user set 1
	userSet2 = 2,			///< \~chinese 銆愯鍐欍€戠浉链洪厤缃泦鍚?    ///< \~english user set 2
	userSetInvalid
}GENICAM_EConfigSet;

/// \~chinese
/// \brief GENICAM_UserSetControl 涓嫔睘镐ф搷浣灭被
/// \~english
/// \brief UserSetControl property operation class
typedef struct GENICAM_UserSetControl
{
	/// \~chinese
	/// 搴曞眰绉佹湁鏁版嵁
	/// \~english
	/// Underlying private data
	void *priv;

	/// \~chinese
	/// 澧炲姞鎺ュ彛寮旷敤
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \~english
	/// add interface reference
	/// \param [in] thiz this pointer
	int32_t (*addRef)(struct GENICAM_UserSetControl *thiz);

	/// \~chinese
	/// 閲婃斁鎺ュ彛
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \~english
	/// release interface
	/// \param [in] thiz this pointer
	int32_t (*release)(struct GENICAM_UserSetControl *thiz);

	/// \~chinese
	/// \brief 鎭㈠鐩告満榛樿閰岖疆
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 鎴愬姛杩斿洖0锛屽惁鍒栾繑锲?1
	/// \~english
	/// \brief restore default 
	/// \param [in] thiz this pointer
	/// \return success:0, fail:-1
	int32_t (*restoreDefault)(struct GENICAM_UserSetControl *thiz);

	/// \~chinese
	/// \brief 璁剧疆鐩告満褰揿墠閰岖疆锛屽苟鐢熸晥涓斾笅娆′互璇ラ厤缃惎锷?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \param [in] configSet 瑕佽缃殑閰岖疆板嗗悎
	/// \return 鎴愬姛杩斿洖0锛屽惁鍒栾繑锲?1
	/// \~english
	/// \brief set current camera configuration, these configurations will take effect immediately and load this userset on next time when start camera
	/// \param [in] thiz this pointer
	/// \param [in] configSet configuration set 
	/// \return success:0, fail:-1
	int32_t (*setCurrentUserSet)(struct GENICAM_UserSetControl *thiz, GENICAM_EConfigSet configSet);

	/// \~chinese
	/// \brief 淇濆瓨鐩告満褰揿墠閰岖疆鍒版煇閰岖疆板嗗悎锛屽userSet1
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \param [in] configSet 瑕佷缭瀛桦埌镄勯厤缃泦鍚?
	/// \return 鎴愬姛杩斿洖0锛屽惁鍒栾繑锲?1
	/// \~english
	/// \brief save current configuration into certain userset, for example, userSet1
	/// \param [in] thiz this pointer
	/// \param [in] configSet User set which is going to save
	/// \return success:0, fail:-1
	int32_t (*saveUserSet)(struct GENICAM_UserSetControl *thiz, GENICAM_EConfigSet configSet);

	/// \~chinese
	/// \brief 銮峰彇鐩告満褰揿墠閰岖疆板嗗悎
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖閰岖疆板嗗悎鏋氢妇链?
	/// \~english
	/// \brief get current user set
	/// \param [in] thiz this pointer
	/// \return user set enumeration value
	GENICAM_EConfigSet (*getCurrentUserSet)(struct GENICAM_UserSetControl *thiz);

	/// \~chinese
	/// \brief 銮峰彇鐩告満褰揿墠UserSet鐩稿叧鏄惁鍙敤
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 鍙敤杩斿洖0锛屽惁鍒栾繑锲?1
	/// \~english
	/// \brief check validity of current user set 
	/// \param [in] thiz this pointer
	/// \return available:0, not available:-1
	int32_t (*isAvailable)(struct GENICAM_UserSetControl *thiz);

	uint32_t reserve[24];					 ///< \~chinese 棰勭暀瀛楁    ///< \~english reserved field

}GENICAM_UserSetControl;

/// \~chinese
/// \brief 鍒涘缓灞炴€ц妭镣筓serSetControl淇℃伅
/// 32浣岖郴缁熶笅128瀛楄妭
/// \~english
/// \brief create UserSetControl info
/// 128 bytes in 32-bit system
typedef struct GENICAM_UserSetControlInfo
{
	GENICAM_Camera*  pCamera;	///< \~chinese 鐩告満瀵硅薄    ///< \~english camera object
	uint32_t reserved[31];	    ///< \~chinese 淇濈暀        ///< \~english reserved field
} GENICAM_UserSetControlInfo;

/// \~chinese
/// 鍒涘缓灞炴€ц妭镣筓serSetControl
/// \param [in]  pUserSetControlInfo 鍒涘缓灞炴€ц妭镣筓serSetControl瀵硅薄镄勫弬鏁?
/// \param [out] ppUserSetControl 灞炴€ц妭镣筓serSetControl瀵硅薄
/// \retval < 0 鍒涘缓澶辫触
/// \retval 0   鍒涘缓鎴愬姛
/// \~english
/// create UserSetControl
/// \param [in]  pUserSetControlInfo create UserSetControl info
/// \param [out] ppUserSetControl    UserSetControl object
/// \retval < 0 create failed
/// \retval 0   create successfully
GENICAM_API int32_t CALL_METHOD GENICAM_createUserSetControl(GENICAM_UserSetControlInfo* pUserSetControlInfo
										, GENICAM_UserSetControl** ppUserSetControl);


/// \~chinese
/// \brief GENICAM_ISPControl 涓嫔睘镐ф搷浣灭被
/// \~english
/// \brief ISPControl property operation class
typedef struct GENICAM_ISPControl
{
	/// \~chinese
	/// 搴曞眰绉佹湁鏁版嵁
	/// \~english
	/// Underlying private data
	void *priv;

	/// \~chinese
	/// 澧炲姞鎺ュ彛寮旷敤
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \~english
	/// add interface reference
	/// \param [in] thiz this pointer
	int32_t (*addRef)(struct GENICAM_ISPControl *thiz);

	/// \~chinese
	/// 閲婃斁鎺ュ彛
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \~english
	/// release interface
	/// \param [in] thiz this pointer
	int32_t (*release)(struct GENICAM_ISPControl *thiz);

	/// \~chinese
	/// \brief 銮峰彇Brightness灞炴€ф搷浣滃璞★紝璁剧疆浜害
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖灞炴€ф搷浣滃璞★紝澶辫触杩斿洖NULL
	/// \~english
	/// \brief get Brightness property operation object, set brightness
	/// \param [in] thiz this pointer
	/// \return success:return property operation object, fail:return NULL
	GENICAM_IntNode (*brightness)(struct GENICAM_ISPControl *thiz);

	/// \~chinese
	/// \brief 銮峰彇Sharpness灞炴€ф搷浣滃璞★紝璁剧疆阌愬害
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖灞炴€ф搷浣滃璞★紝澶辫触杩斿洖NULL
	/// \~english
	/// \brief get Sharpness property operation object, set sharpness
	/// \param [in] thiz this pointer
	/// \return success:return property operation object, fail:return NULL
	GENICAM_IntNode (*sharpness)(struct GENICAM_ISPControl *thiz);

	/// \~chinese
	/// \brief 銮峰彇SharpnessAuto灞炴€ф搷浣滃璞★紝璁剧疆鏄惁镊姩阌愬害
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖灞炴€ф搷浣滃璞★紝澶辫触杩斿洖NULL
	/// \~english
	/// \brief get SharpnessAuto property operation object, set whether activate auto sharpness or not
	/// \param [in] thiz this pointer
	/// \return success:return property operation object, fail:return NULL
	GENICAM_BoolNode (*sharpnessAuto)(struct GENICAM_ISPControl *thiz);

	/// \~chinese
	/// \brief 銮峰彇SharpnessEnable灞炴€ф搷浣滃璞★紝璁剧疆鏄惁寮€鍚攼搴?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖灞炴€ф搷浣滃璞★紝澶辫触杩斿洖NULL
	/// \~english 
	/// \brief get SharpnessEnable property operation object, set whether enable sharpness or not
	/// \param [in] thiz this pointer
	/// \return success:return property operation object, fail:return NULL
	GENICAM_EnumNode (*sharpnessEnable)(struct GENICAM_ISPControl *thiz);

	/// \~chinese
	/// \brief 銮峰彇Contrast灞炴€ф搷浣滃璞★紝璁剧疆瀵规瘮搴?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖灞炴€ф搷浣滃璞★紝澶辫触杩斿洖NULL
	/// \~english
	/// \brief get Contrast property operation object, set contrast
	/// \param [in] thiz this pointer
	/// \return success:return property operation object, fail:return NULL
	GENICAM_IntNode (*contrast)(struct GENICAM_ISPControl *thiz);

	/// \~chinese
	/// \brief 銮峰彇Hue灞炴€ф搷浣滃璞★紝璁剧疆鑹插害
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖灞炴€ф搷浣滃璞★紝澶辫触杩斿洖NULL
	/// \~english
	/// \brief get Hue property operation object, set hue
	/// \param [in] thiz this pointer
	/// \return success:return property operation object, fail:return NULL
	GENICAM_IntNode (*hue)(struct GENICAM_ISPControl *thiz);

	/// \~chinese
	/// \brief 銮峰彇Saturation灞炴€ф搷浣滃璞★紝璁剧疆楗卞拰搴?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖灞炴€ф搷浣滃璞★紝澶辫触杩斿洖NULL
	/// \~english
	/// \brief get Saturation property operation object, set saturation
	/// \param [in] thiz this pointer
	/// \return success:return property operation object, fail:return NULL
	GENICAM_IntNode (*saturation)(struct GENICAM_ISPControl *thiz);

	uint32_t reserved[22];	   ///< \~chinese 淇濈暀    ///< \~english reserved field

}GENICAM_ISPControl;

/// \~chinese
/// \brief 鍒涘缓灞炴€ц妭镣逛俊鎭?
/// 32浣岖郴缁熶笅128瀛楄妭
/// \~english
/// \brief create property node info
/// 128 bytes in 32-bit system
typedef struct GENICAM_ISPControlInfo
{
	GENICAM_Camera*  pCamera;	///< \~chinese 鐩告満瀵硅薄    ///< \~english camera object
	uint32_t reserved[31];	    ///< \~chinese 淇濈暀        ///< \~english reserved field
} GENICAM_ISPControlInfo;

/// \~chinese
/// 鍒涘缓灞炴€ц妭镣?
/// \param [in]  pISPControlInfo 鍒涘缓灞炴€ц妭镣笽SPControl瀵硅薄镄勫弬鏁?
/// \param [out] ppISPControl 灞炴€ц妭镣笽SPControl瀵硅薄
/// \retval < 0 鍒涘缓澶辫触
/// \retval 0   鍒涘缓鎴愬姛
/// \~english
/// create property node
/// \param [in]  pISPControlInfo create ISPControl info
/// \param [out] ppISPControl    create ISPControl object
/// \retval < 0 create failed
/// \retval 0   create successfully
GENICAM_API int32_t CALL_METHOD GENICAM_createISPControl(GENICAM_ISPControlInfo* pISPControlInfo
				, GENICAM_ISPControl** ppISPControl);


/// \~chinese
/// \brief AnalogControl 涓嫔睘镐ф搷浣灭被
/// 32浣岖郴缁熶笅128瀛楄妭
/// \~english
/// \brief AnalogControl property operation class
/// 128 bytes in 32-bit system
typedef struct GENICAM_AnalogControl
{
	/// \~chinese
	/// 搴曞眰绉佹湁鏁版嵁
	/// \~english
	/// Underlying private data
	void *priv;

	/// \~chinese
	/// 澧炲姞鎺ュ彛寮旷敤
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \~english
	/// add interface reference
	/// \param [in] thiz this pointer
	int32_t (*addRef)(struct GENICAM_AnalogControl *thiz);

	/// \~chinese
	/// 閲婃斁鎺ュ彛
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \~english
	/// release interface
	/// \param [in] thiz this pointer
	int32_t (*release)(struct GENICAM_AnalogControl *thiz);

	/// \~chinese
	/// \brief 銮峰彇BlackLevelSelector灞炴€ф搷浣滃璞★紝璁剧疆鎿崭綔鍝釜鐧藉钩琛?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖灞炴€ф搷浣滃璞★紝澶辫触杩斿洖NULL
	/// \~english
	/// \brief get BlackLevelSelector property operation object
	/// \param [in] thiz this pointer
	/// \return success:return property operation object, fail:return NULL
	GENICAM_EnumNode (*blackLevelSelector)(struct GENICAM_AnalogControl *thiz);

	/// \~chinese
	/// \brief 銮峰彇BlackLevelAuto灞炴€ф搷浣滃璞★紝璁剧疆镊姩鐧藉钩琛?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖灞炴€ф搷浣滃璞★紝澶辫触杩斿洖NULL
	/// \~english
	/// \brief get BalanceWhiteAuto property operation object, set auto white balance
	/// \param [in] thiz this pointer
	/// \return success:return property operation object, fail:return NULL
	GENICAM_EnumNode (*blackLevelAuto)(struct GENICAM_AnalogControl *thiz);

	/// \~chinese
	/// \brief 銮峰彇BlackLevel灞炴€ф搷浣滃璞★紝璁剧疆鐧藉钩琛″€?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖灞炴€ф搷浣滃璞★紝澶辫触杩斿洖NULL
	/// \~english
	/// \brief get BlackLevel property operation object, set black level
	/// \param [in] thiz this pointer
	/// \return success:return property operation object, fail:return NULL
	GENICAM_IntNode (*blackLevel)(struct GENICAM_AnalogControl *thiz);

	/// \~chinese
	/// \brief 銮峰彇GainAuto灞炴€ф搷浣滃璞?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖灞炴€ф搷浣滃璞★紝澶辫触杩斿洖NULL
	/// \~english
	/// \brief get GainAuto property operation object
	/// \param [in] thiz this pointer
	/// \return success:return property operation object, fail:return NULL
	GENICAM_EnumNode (*gainAuto)(struct GENICAM_AnalogControl *thiz);

	/// \~chinese
	/// \brief 銮峰彇GainRaw灞炴€ф搷浣滃璞?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖灞炴€ф搷浣滃璞★紝澶辫触杩斿洖NULL
	/// \~english
	/// \brief get GainRaw operation object
	/// \param [in] thiz this pointer
	/// \return success:return property operation object, fail:return NULL
	GENICAM_DoubleNode (*gainRaw)(struct GENICAM_AnalogControl *thiz);

	/// \~chinese
	/// \brief 銮峰彇Gamma灞炴€ф搷浣滃璞★紝璁剧疆Gamma链?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖灞炴€ф搷浣滃璞★紝澶辫触杩斿洖NULL
	/// \~english
	/// \brief get Gamma operation object, set gamma
	/// \param [in] thiz this pointer
	/// \return success:return property operation object, fail:return NULL
	GENICAM_DoubleNode (*gamma)(struct GENICAM_AnalogControl *thiz);
	
	/// \~chinese
	/// \brief 銮峰彇BalanceRatioSelector灞炴€ф搷浣滃璞★紝璁剧疆鎿崭綔鍝釜鐧藉钩琛?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖灞炴€ф搷浣滃璞★紝澶辫触杩斿洖NULL
	/// \~english
	/// \brief get BalanceRatioSelector property operation object
	/// \param [in] thiz this pointer
	/// \return success:return property operation object, fail:return NULL
	GENICAM_EnumNode (*balanceRatioSelector)(struct GENICAM_AnalogControl *thiz);
	
	/// \~chinese
	/// \brief 銮峰彇BalanceWhiteAuto灞炴€ф搷浣滃璞★紝璁剧疆镊姩鐧藉钩琛?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖灞炴€ф搷浣滃璞★紝澶辫触杩斿洖NULL
	/// \~english
	/// \brief get BalanceWhiteAuto property operation object, set auto white balance
	/// \param [in] thiz this pointer
	/// \return success:return property operation object, fail:return NULL
	GENICAM_EnumNode (*balanceWhiteAuto)(struct GENICAM_AnalogControl *thiz);
	
	/// \~chinese
	/// \brief 銮峰彇BalanceRatioSelector灞炴€ф搷浣滃璞★紝璁剧疆鎿崭綔鍝釜鐧藉钩琛?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖灞炴€ф搷浣滃璞★紝澶辫触杩斿洖NULL
	/// \~english
	/// \brief get BalanceRatioSelector property operation object
	/// \param [in] thiz this pointer
	/// \return success:return property operation object, fail:return NULL
	GENICAM_DoubleNode (*balanceRatio)(struct GENICAM_AnalogControl *thiz);
	
	uint32_t reserve[20];					 ///< \~chinese 棰勭暀瀛楁    ///< \~english reserved field
}GENICAM_AnalogControl;

/// \~chinese
/// \brief 鍒涘缓灞炴€ц妭镣逛俊鎭?
/// 32浣岖郴缁熶笅128瀛楄妭
/// \~english
/// \brief create property node info
/// 128 bytes in 32-bit system
typedef struct GENICAM_AnalogControlInfo
{
	GENICAM_Camera*  pCamera;	///< \~chinese 鐩告満瀵硅薄    ///< \~english camera object
	uint32_t reserved[31];	    ///< \~chinese 淇濈暀        ///< \~english reserved field
} GENICAM_AnalogControlInfo;

/// \~chinese
/// 鍒涘缓灞炴€ц妭镣?
/// \param [in]  pAnalogControlInfo 鍒涘缓灞炴€ц妭镣笰nalogControl瀵硅薄镄勫弬鏁?
/// \param [out] ppAnalogControl    灞炴€ц妭镣笰nalogControl瀵硅薄
/// \retval < 0 鍒涘缓澶辫触
/// \retval 0   鍒涘缓鎴愬姛
/// \~english
/// create property node
/// \param [in]  pAnalogControlInfo create AnalogControl info
/// \param [out] ppAnalogControl    AnalogControl object
/// \retval < 0 create failed
/// \retval 0   create successfully
GENICAM_API int32_t  CALL_METHOD GENICAM_createAnalogControl(GENICAM_AnalogControlInfo* pAnalogControlInfo
						, GENICAM_AnalogControl** ppAnalogControl);


/// \~chinese
/// \brief GENICAM_DeviceControl 涓嫔睘镐ф搷浣灭被
/// 32浣岖郴缁熶笅128瀛楄妭
/// \~english
/// \brief DeviceControl property operation calss
/// 128 bytes in 32-bit system
typedef struct GENICAM_DeviceControl
{
	/// \~chinese
	/// 搴曞眰绉佹湁鏁版嵁
	/// \~english
	/// Underlying private data
	void *priv;

	/// \~chinese
	/// 澧炲姞鎺ュ彛寮旷敤
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \~english
	/// add interface reference
	/// \param [in] thiz this pointer
	int32_t (*addRef)(struct GENICAM_DeviceControl *thiz);

	/// \~chinese
	/// 閲婃斁鎺ュ彛
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \~english
	/// release interface
	/// \param [in] thiz this pointer
	int32_t (*release)(struct GENICAM_DeviceControl *thiz);

	/// \~chinese
	/// \brief 銮峰彇DeviceUserID灞炴€ф搷浣滃璞★紝璇ュ璞″彲璇诲啓
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖灞炴€ф搷浣滃璞★紝澶辫触杩斿洖NULL
	/// \~english
	/// \brief get DeviceUserID property operation object which are readable and writable
	/// \param [in] thiz this pointer
	/// \return success:return property operation object, fail:return NULL
	GENICAM_StringNode (*deviceUserID)(struct GENICAM_DeviceControl *thiz);

	uint32_t reserve[28];    ///< \~chinese 棰勭暀瀛楁    ///< \~english reserved field
}GENICAM_DeviceControl;

/// \~chinese
/// \brief 鍒涘缓灞炴€ц妭镣逛俊鎭?
/// 32浣岖郴缁熶笅128瀛楄妭
/// \~english
/// \brief create property node info
/// 128 bytes in 32-bit system
typedef struct GENICAM_DeviceControlInfo
{
	GENICAM_Camera*  pCamera;	///< \~chinese 鐩告満瀵硅薄    ///< \~english camera object
	uint32_t reserved[31];	    ///< \~chinese 淇濈暀        ///< \~english reserved field
} GENICAM_DeviceControlInfo;

/// \~chinese
/// 鍒涘缓灞炴€ц妭镣?
/// \param [in]  pDeviceControlInfo 鍒涘缓灞炴€ц妭镣笵eviceControl瀵硅薄镄勫弬鏁?
/// \param [out] ppDeviceControl    灞炴€ц妭镣笵eviceControl瀵硅薄
/// \retval < 0 鍒涘缓澶辫触
/// \retval 0   鍒涘缓鎴愬姛
/// \~english
/// create property node
/// \param [in]  pDeviceControlInfo create DeviceControl info
/// \param [out] ppDeviceControl    DeviceControl object
/// \retval < 0 create failed
/// \retval 0   create successfully
GENICAM_API int32_t CALL_METHOD GENICAM_createDeviceControl(GENICAM_DeviceControlInfo* pDeviceControlInfo
									, GENICAM_DeviceControl** ppDeviceControl);


/// \~chinese
/// \brief GENICAM_DigitalIOControl 涓嫔睘镐ф搷浣灭被
/// 32浣岖郴缁熶笅128瀛楄妭
/// \~english
/// \brief DigitalIOControl property operation calss
/// 128 bytes in 32-bit system
typedef struct GENICAM_DigitalIOControl
{
	/// \~chinese
	/// 搴曞眰绉佹湁鏁版嵁
	/// \~english
	/// Underlying private data
	void *priv;

	/// \~chinese
	/// 澧炲姞鎺ュ彛寮旷敤
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \~english
	/// add interface reference
	/// \param [in] thiz this pointer
	int32_t(*addRef)(struct GENICAM_DigitalIOControl *thiz);

	/// \~chinese
	/// 閲婃斁鎺ュ彛
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \~english
	/// release interface
	/// \param [in] thiz this pointer
	int32_t(*release)(struct GENICAM_DigitalIOControl *thiz);

	/// \~chinese
	/// \brief 銮峰彇LineSelector灞炴€ф搷浣滃璞★紝璇ュ璞″彲璇诲啓
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖灞炴€ф搷浣滃璞★紝澶辫触杩斿洖NULL
	/// \~english
	/// \brief get LineSelector property operation object which is readable and writable
	/// \param [in] thiz this pointer
	/// \return success:return property operation object, fail:return NULL
	GENICAM_EnumNode(*lineSelector)(struct GENICAM_DigitalIOControl *thiz);

	/// \~chinese
	/// \brief 銮峰彇LineDebouncerTimeAbs灞炴€ф搷浣滃璞★紝璇ュ璞″彲璇?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖灞炴€ф搷浣滃璞★紝澶辫触杩斿洖NULL
	/// \~english
	/// \brief get LineDebouncerTimeAbs property operation object which is readable and writable 
	/// \param [in] thiz this pointer
	/// \return success:return property operation object, fail:return NULL
	GENICAM_DoubleNode(*lineDebouncerTimeAbs)(struct GENICAM_DigitalIOControl *thiz);

	/// \~chinese
	/// \brief 銮峰彇UserOutputSelector灞炴€ф搷浣滃璞★紝璇ュ璞″彲璇诲啓
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖灞炴€ф搷浣滃璞★紝澶辫触杩斿洖NULL
	/// \~english
	/// \brief get UserOutputSelector property operation object which is readable and writable
	/// \param [in] thiz this pointer
	/// \return success:return property operation object, fail:return NULL
	GENICAM_EnumNode(*userOutputSelector)(struct GENICAM_DigitalIOControl *thiz);

	/// \~chinese
	/// \brief 銮峰彇UserOutputValue灞炴€ф搷浣滃璞★紝璇ュ璞″彲璇诲啓
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖灞炴€ф搷浣滃璞★紝澶辫触杩斿洖NULL
	/// \~english
	/// \brief get UserOutputValue's property operation object which is readable and writable
	/// \param [in] thiz this pointer
	/// \return success:return property operation object, fail:return NULL
	GENICAM_BoolNode(*userOutputValue)(struct GENICAM_DigitalIOControl *thiz);


	uint32_t reserve[25];    ///< \~chinese 棰勭暀瀛楁    ///< \~english reserved field
}GENICAM_DigitalIOControl;

/// \~chinese
/// \brief 鍒涘缓灞炴€ц妭镣逛俊鎭?
/// 32浣岖郴缁熶笅128瀛楄妭
/// \~english
/// \brief create property node info
/// 128 bytes in 32-bit system
typedef struct GENICAM_DigitalIOControlInfo
{
	GENICAM_Camera*  pCamera;	///< \~chinese 鐩告満瀵硅薄    ///< \~english camera object
	uint32_t reserved[31];	    ///< \~chinese 淇濈暀        ///< \~english reserved field
} GENICAM_DigitalIOControlInfo;

/// \~chinese
/// 鍒涘缓灞炴€ц妭镣?
/// \param [in]  pDigitalIOControlInfo 鍒涘缓灞炴€ц妭镣笵igitalIOControl瀵硅薄镄勫弬鏁?
/// \param [out] ppDigitalIOControl    灞炴€ц妭镣笵igitalIOControl瀵硅薄
/// \retval < 0 鍒涘缓澶辫触
/// \retval 0   鍒涘缓鎴愬姛
/// \~english
/// create property node
/// \param [in]  pDigitalIOControlInfo create DigitalIOControl info
/// \param [out] ppDigitalIOControl    DigitalIOControl object
/// \retval < 0 create failed
/// \retval 0   create successfully
GENICAM_API int32_t CALL_METHOD GENICAM_createDigitalIOControl(GENICAM_DigitalIOControlInfo* pDigitalIOControlInfo
	, GENICAM_DigitalIOControl** ppDigitalIOControl);


/// \~chinese
/// \brief GENICAM_TransportLayerControl 涓嫔睘镐ф搷浣灭被
/// 32浣岖郴缁熶笅128瀛楄妭
/// \~english
/// \brief TransportLayerControl property operation class 
/// 128 bytes in 32-bit system
typedef struct GENICAM_TransportLayerControl
{
	/// \~chinese
	/// 搴曞眰绉佹湁鏁版嵁
	/// \~english
	/// Underlying private data
	void *priv;

	/// \~chinese
	/// 澧炲姞鎺ュ彛寮旷敤
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \~english
	/// add interface reference
	/// \param [in] thiz this pointer
	int32_t (*addRef)(struct GENICAM_TransportLayerControl *thiz);

	/// \~chinese
	/// 閲婃斁鎺ュ彛
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \~english
	/// release interface
	/// \param [in] thiz this pointer
	int32_t (*release)(struct GENICAM_TransportLayerControl *thiz);

	/// \~chinese
	/// \brief 銮峰彇GevSCPD灞炴€ф搷浣滃璞★紝璁剧疆鍖呭彂阃侀棿闅?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖灞炴€ф搷浣滃璞★紝澶辫触杩斿洖NULL
	/// \~english
	/// \brief get GevSCPD property operation object, set packet sending interval 
	/// \param [in] thiz this pointer
	/// \return success:return property operation object, fail:return NULL
	GENICAM_IntNode (*gevSCPD)(struct GENICAM_TransportLayerControl *thiz);

	uint32_t reserve[28];    ///< \~chinese 棰勭暀瀛楁    ///< \~english reserved field

}GENICAM_TransportLayerControl;

/// \~chinese
/// \brief 鍒涘缓灞炴€ц妭镣逛俊鎭?
/// 32浣岖郴缁熶笅128瀛楄妭
/// \~english
/// \brief create property node info
/// 128 bytes in 32-bit system
typedef struct GENICAM_TransportLayerControlInfo
{
	GENICAM_Camera*  pCamera;	///< \~chinese 鐩告満瀵硅薄    ///< \~english camera object
	uint32_t reserved[31];	    ///< \~chinese 淇濈暀        ///< \~english reserved field
} GENICAM_TransportLayerControlInfo;

/// \~chinese
/// 鍒涘缓灞炴€ц妭镣?
/// \param [in]  pTransportControlInfo 鍒涘缓灞炴€ц妭镣筎ransportLayerControl瀵硅薄镄勫弬鏁?
/// \param [out] ppTransportControl   灞炴€ц妭镣筎ransportLayerControl瀵硅薄
/// \retval < 0 鍒涘缓澶辫触
/// \retval 0   鍒涘缓鎴愬姛
/// \~english
/// create property node
/// \param [in]  pTransportControlInfo create TransportLayerControl info
/// \param [out] ppTransportControl    TransportLayerControl object
/// \retval < 0 create failed
/// \retval 0   create successfully
GENICAM_API int32_t CALL_METHOD GENICAM_createTransportLayerControl(GENICAM_TransportLayerControlInfo* pTransportControlInfo
								, GENICAM_TransportLayerControl** ppTransportControl);


/// \~chinese
/// \brief GENICAM_ImageFormatControl 涓嫔睘镐ф搷浣灭被
/// 32浣岖郴缁熶笅128瀛楄妭
/// \~english
/// \brief ImageFormatControl property operation class
/// 128 bytes in 32-bit system
typedef struct GENICAM_ImageFormatControl
{
	/// \~chinese
	/// 搴曞眰绉佹湁鏁版嵁
	/// \~english
	/// Underlying private data
	void *priv;

	/// \~chinese
	/// 澧炲姞鎺ュ彛寮旷敤
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \~english
	/// add interface reference
	/// \param [in] thiz this pointer
	int32_t (*addRef)(struct GENICAM_ImageFormatControl *thiz);

	/// \~chinese
	/// 閲婃斁鎺ュ彛
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \~english
	/// release interface
	/// \param [in] thiz this pointer
	int32_t (*release)(struct GENICAM_ImageFormatControl *thiz);

	/// \~chinese
	/// \brief 銮峰彇Height灞炴€ф搷浣滃璞?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖灞炴€ф搷浣滃璞★紝澶辫触杩斿洖NULL
	/// \~english
	/// \brief get Height property operation object
	/// \param [in] thiz this pointer
	/// \return success:property's object, fail:NULL
	GENICAM_IntNode (*height)(struct GENICAM_ImageFormatControl *thiz);

	/// \~chinese
	/// \brief 銮峰彇Width灞炴€ф搷浣滃璞?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖灞炴€ф搷浣滃璞★紝澶辫触杩斿洖NULL
	/// \~english
	/// \brief get Width property operation object
	/// \param [in] thiz this pointer
	/// \return success:property's object, fail:NULL
	GENICAM_IntNode (*width)(struct GENICAM_ImageFormatControl *thiz);

	/// \~chinese
	/// \brief 銮峰彇OffsetX灞炴€ф搷浣滃璞?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖灞炴€ф搷浣滃璞★紝澶辫触杩斿洖NULL
	/// \~english
	/// \brief get OffsetX property operation object
	/// \param [in] thiz this pointer
	/// \return success:property's object, fail:NULL
	GENICAM_IntNode (*offsetX)(struct GENICAM_ImageFormatControl *thiz);

	/// \~chinese
	/// \brief 銮峰彇OffsetY灞炴€ф搷浣滃璞?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖灞炴€ф搷浣滃璞★紝澶辫触杩斿洖NULL
	/// \~english
	/// \brief get OffsetY property operation object
	/// \param [in] thiz this pointer
	/// \return success:property's object, fail:NULL
	GENICAM_IntNode (*offsetY)(struct GENICAM_ImageFormatControl *thiz);

	/// \~chinese
	/// \brief 銮峰彇PixelFormat灞炴€ф搷浣滃璞?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖灞炴€ф搷浣滃璞★紝澶辫触杩斿洖NULL
	/// \~english
	/// \brief get PixelFormat property operation object
	/// \param [in] thiz this pointer
	/// \return success:property's object, fail:NULL
	GENICAM_EnumNode (*pixelFormat)(struct GENICAM_ImageFormatControl *thiz);

	/// \~chinese
	/// \brief 銮峰彇ReverseX灞炴€ф搷浣滃璞★紝璁剧疆鏄惁缈昏浆锲惧儚X杞?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖灞炴€ф搷浣滃璞★紝澶辫触杩斿洖NULL
	/// \~english
	/// \brief get ReverseX property operation object, set whether reverse X or not
	/// \param [in] thiz this pointer
	/// \return property operation object,return NULL if failed
	GENICAM_BoolNode (*reverseX)(struct GENICAM_ImageFormatControl *thiz);

	/// \~chinese
	/// \brief 銮峰彇ReverseY灞炴€ф搷浣滃璞★紝璁剧疆鏄惁缈昏浆锲惧儚Y杞?
	/// \param [in] thiz 链帴鍙ｆ寚阍?
	/// \return 杩斿洖灞炴€ф搷浣滃璞★紝澶辫触杩斿洖NULL
	/// \~english
	/// \brief get ReverseY property operation object, set whether reverse Y or not
	/// \param [in] thiz this pointer
	/// \return property operation object,return NULL if failed
	GENICAM_BoolNode (*reverseY)(struct GENICAM_ImageFormatControl *thiz);

	uint32_t reserve[22];					 ///< \~chinese 棰勭暀瀛楁    ///< \~english reserved field

}GENICAM_ImageFormatControl;

/// \~chinese
/// \brief 鍒涘缓灞炴€ц妭镣逛俊鎭?
/// 32浣岖郴缁熶笅128瀛楄妭
/// \~english
/// \brief create property node info
/// 128 bytes in 32-bit system
typedef struct GENICAM_ImageFormatControlInfo
{
	GENICAM_Camera*  pCamera;	///< \~chinese 鐩告満瀵硅薄    ///< \~english camera object
	uint32_t reserved[31];	    ///< \~chinese 淇濈暀        ///< \~english reserved field
} GENICAM_ImageFormatControlInfo;

/// \~chinese
/// 鍒涘缓灞炴€ц妭镣?
/// \param [in]  pImageFormatControlInfo 鍒涘缓灞炴€ц妭镣笽mageFormatControl瀵硅薄镄勫弬鏁?
/// \param [out] ppImageFormatControl    灞炴€ц妭镣笽mageFormatControl瀵硅薄
/// \retval < 0 鍒涘缓澶辫触
/// \retval 0   鍒涘缓鎴愬姛
/// \~english
/// create property node
/// \param [in]  pImageFormatControlInfo create ImageFormatControl info
/// \param [out] ppImageFormatControl    ImageFormatControl object
/// \retval < 0 create failed
/// \retval 0   create successfully
GENICAM_API int32_t  CALL_METHOD GENICAM_createImageFormatControl(GENICAM_ImageFormatControlInfo* pImageFormatControlInfo,
												GENICAM_ImageFormatControl** ppImageFormatControl);

/// @}


#ifdef __cplusplus
}
#endif 

#endif